diff options
Diffstat (limited to 'xfa_test/pdf/paint_manager.cc')
| -rw-r--r-- | xfa_test/pdf/paint_manager.cc | 302 |
1 files changed, 0 insertions, 302 deletions
diff --git a/xfa_test/pdf/paint_manager.cc b/xfa_test/pdf/paint_manager.cc deleted file mode 100644 index f452b37186..0000000000 --- a/xfa_test/pdf/paint_manager.cc +++ /dev/null @@ -1,302 +0,0 @@ -// Copyright (c) 2010 The Chromium Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. - -#include "pdf/paint_manager.h" - -#include <algorithm> - -#include "base/logging.h" -#include "ppapi/c/pp_errors.h" -#include "ppapi/cpp/instance.h" -#include "ppapi/cpp/module.h" - -PaintManager::PaintManager(pp::Instance* instance, - Client* client, - bool is_always_opaque) - : instance_(instance), - client_(client), - is_always_opaque_(is_always_opaque), - callback_factory_(NULL), - manual_callback_pending_(false), - flush_pending_(false), - has_pending_resize_(false), - graphics_need_to_be_bound_(false), - pending_device_scale_(1.0), - device_scale_(1.0), - in_paint_(false), - first_paint_(true), - view_size_changed_waiting_for_paint_(false) { - // Set the callback object outside of the initializer list to avoid a - // compiler warning about using "this" in an initializer list. - callback_factory_.Initialize(this); - - // You can not use a NULL client pointer. - DCHECK(client); -} - -PaintManager::~PaintManager() { -} - -// static -pp::Size PaintManager::GetNewContextSize(const pp::Size& current_context_size, - const pp::Size& plugin_size) { - // The amount of additional space in pixels to allocate to the right/bottom of - // the context. - const int kBufferSize = 50; - - // Default to returning the same size. - pp::Size result = current_context_size; - - // The minimum size of the plugin before resizing the context to ensure we - // aren't wasting too much memory. We deduct twice the kBufferSize from the - // current context size which gives a threshhold that is kBufferSize below - // the plugin size when the context size was last computed. - pp::Size min_size( - std::max(current_context_size.width() - 2 * kBufferSize, 0), - std::max(current_context_size.height() - 2 * kBufferSize, 0)); - - // If the plugin size is bigger than the current context size, we need to - // resize the context. If the plugin size is smaller than the current - // context size by a given threshhold then resize the context so that we - // aren't wasting too much memory. - if (plugin_size.width() > current_context_size.width() || - plugin_size.height() > current_context_size.height() || - plugin_size.width() < min_size.width() || - plugin_size.height() < min_size.height()) { - // Create a larger context than needed so that if we only resize by a - // small margin, we don't need a new context. - result = pp::Size(plugin_size.width() + kBufferSize, - plugin_size.height() + kBufferSize); - } - - return result; -} - -void PaintManager::Initialize(pp::Instance* instance, - Client* client, - bool is_always_opaque) { - DCHECK(!instance_ && !client_); // Can't initialize twice. - instance_ = instance; - client_ = client; - is_always_opaque_ = is_always_opaque; -} - -void PaintManager::SetSize(const pp::Size& new_size, float device_scale) { - if (GetEffectiveSize() == new_size && - GetEffectiveDeviceScale() == device_scale) - return; - - has_pending_resize_ = true; - pending_size_ = new_size; - pending_device_scale_ = device_scale; - - view_size_changed_waiting_for_paint_ = true; - - Invalidate(); -} - -void PaintManager::Invalidate() { - // You must call SetSize before using. - DCHECK(!graphics_.is_null() || has_pending_resize_); - - EnsureCallbackPending(); - aggregator_.InvalidateRect(pp::Rect(GetEffectiveSize())); -} - -void PaintManager::InvalidateRect(const pp::Rect& rect) { - DCHECK(!in_paint_); - - // You must call SetSize before using. - DCHECK(!graphics_.is_null() || has_pending_resize_); - - // Clip the rect to the device area. - pp::Rect clipped_rect = rect.Intersect(pp::Rect(GetEffectiveSize())); - if (clipped_rect.IsEmpty()) - return; // Nothing to do. - - EnsureCallbackPending(); - aggregator_.InvalidateRect(clipped_rect); -} - -void PaintManager::ScrollRect(const pp::Rect& clip_rect, - const pp::Point& amount) { - DCHECK(!in_paint_); - - // You must call SetSize before using. - DCHECK(!graphics_.is_null() || has_pending_resize_); - - EnsureCallbackPending(); - - aggregator_.ScrollRect(clip_rect, amount); -} - -pp::Size PaintManager::GetEffectiveSize() const { - return has_pending_resize_ ? pending_size_ : plugin_size_; -} - -float PaintManager::GetEffectiveDeviceScale() const { - return has_pending_resize_ ? pending_device_scale_ : device_scale_; -} - -void PaintManager::EnsureCallbackPending() { - // The best way for us to do the next update is to get a notification that - // a previous one has completed. So if we're already waiting for one, we - // don't have to do anything differently now. - if (flush_pending_) - return; - - // If no flush is pending, we need to do a manual call to get back to the - // main thread. We may have one already pending, or we may need to schedule. - if (manual_callback_pending_) - return; - - pp::Module::Get()->core()->CallOnMainThread( - 0, - callback_factory_.NewCallback(&PaintManager::OnManualCallbackComplete), - 0); - manual_callback_pending_ = true; -} - -void PaintManager::DoPaint() { - in_paint_ = true; - - std::vector<ReadyRect> ready; - std::vector<pp::Rect> pending; - - DCHECK(aggregator_.HasPendingUpdate()); - - // Apply any pending resize. Setting the graphics to this class must happen - // before asking the plugin to paint in case it requests invalides or resizes. - // However, the bind must not happen until afterward since we don't want to - // have an unpainted device bound. The needs_binding flag tells us whether to - // do this later. - if (has_pending_resize_) { - plugin_size_ = pending_size_; - // Only create a new graphics context if the current context isn't big - // enough or if it is far too big. This avoids creating a new context if - // we only resize by a small amount. - pp::Size new_size = GetNewContextSize(graphics_.size(), pending_size_); - if (graphics_.size() != new_size) { - graphics_ = pp::Graphics2D(instance_, new_size, is_always_opaque_); - graphics_need_to_be_bound_ = true; - - // Since we're binding a new one, all of the callbacks have been canceled. - manual_callback_pending_ = false; - flush_pending_ = false; - callback_factory_.CancelAll(); - } - - if (pending_device_scale_ != 1.0) - graphics_.SetScale(1.0 / pending_device_scale_); - device_scale_ = pending_device_scale_; - - // This must be cleared before calling into the plugin since it may do - // additional invalidation or sizing operations. - has_pending_resize_ = false; - pending_size_ = pp::Size(); - } - - PaintAggregator::PaintUpdate update = aggregator_.GetPendingUpdate(); - client_->OnPaint(update.paint_rects, &ready, &pending); - - if (ready.empty() && pending.empty()) { - in_paint_ = false; - return; // Nothing was painted, don't schedule a flush. - } - - std::vector<PaintAggregator::ReadyRect> ready_now; - if (pending.empty()) { - std::vector<PaintAggregator::ReadyRect> temp_ready; - for (size_t i = 0; i < ready.size(); ++i) - temp_ready.push_back(ready[i]); - aggregator_.SetIntermediateResults(temp_ready, pending); - ready_now = aggregator_.GetReadyRects(); - aggregator_.ClearPendingUpdate(); - - // Apply any scroll first. - if (update.has_scroll) - graphics_.Scroll(update.scroll_rect, update.scroll_delta); - - view_size_changed_waiting_for_paint_ = false; - } else { - std::vector<PaintAggregator::ReadyRect> ready_later; - for (size_t i = 0; i < ready.size(); ++i) { - // Don't flush any part (i.e. scrollbars) if we're resizing the browser, - // as that'll lead to flashes. Until we flush, the browser will use the - // previous image, but if we flush, it'll revert to using the blank image. - // We make an exception for the first paint since we want to show the - // default background color instead of the pepper default of black. - if (ready[i].flush_now && - (!view_size_changed_waiting_for_paint_ || first_paint_)) { - ready_now.push_back(ready[i]); - } else { - ready_later.push_back(ready[i]); - } - } - // Take the rectangles, except the ones that need to be flushed right away, - // and save them so that everything is flushed at once. - aggregator_.SetIntermediateResults(ready_later, pending); - - if (ready_now.empty()) { - in_paint_ = false; - EnsureCallbackPending(); - return; - } - } - - for (size_t i = 0; i < ready_now.size(); ++i) { - graphics_.PaintImageData( - ready_now[i].image_data, ready_now[i].offset, ready_now[i].rect); - } - - int32_t result = graphics_.Flush( - callback_factory_.NewCallback(&PaintManager::OnFlushComplete)); - - // If you trigger this assertion, then your plugin has called Flush() - // manually. When using the PaintManager, you should not call Flush, it will - // handle that for you because it needs to know when it can do the next paint - // by implementing the flush callback. - // - // Another possible cause of this assertion is re-using devices. If you - // use one device, swap it with another, then swap it back, we won't know - // that we've already scheduled a Flush on the first device. It's best to not - // re-use devices in this way. - DCHECK(result != PP_ERROR_INPROGRESS); - - if (result == PP_OK_COMPLETIONPENDING) { - flush_pending_ = true; - } else { - DCHECK(result == PP_OK); // Catch all other errors in debug mode. - } - - in_paint_ = false; - first_paint_ = false; - - if (graphics_need_to_be_bound_) { - instance_->BindGraphics(graphics_); - graphics_need_to_be_bound_ = false; - } -} - -void PaintManager::OnFlushComplete(int32_t) { - DCHECK(flush_pending_); - flush_pending_ = false; - - // If more paints were enqueued while we were waiting for the flush to - // complete, execute them now. - if (aggregator_.HasPendingUpdate()) - DoPaint(); -} - -void PaintManager::OnManualCallbackComplete(int32_t) { - DCHECK(manual_callback_pending_); - manual_callback_pending_ = false; - - // Just because we have a manual callback doesn't mean there are actually any - // invalid regions. Even though we only schedule this callback when something - // is pending, a Flush callback could have come in before this callback was - // executed and that could have cleared the queue. - if (aggregator_.HasPendingUpdate()) - DoPaint(); -} |