cc: Split Proxy to eliminate unnecessary dependencies on the impl side

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <set>
@@ skipping 121 matching lines @@
 }  // namespace
 
 LayerTreeHostImpl::FrameData::FrameData()
     : render_surface_layer_list(nullptr), has_no_damage(false) {}
 
 LayerTreeHostImpl::FrameData::~FrameData() {}
 
 scoped_ptr<LayerTreeHostImpl> LayerTreeHostImpl::Create(
     const LayerTreeSettings& settings,
     LayerTreeHostImplClient* client,
-    Proxy* proxy,
+    ThreadVerifier* thread_verifier,
     RenderingStatsInstrumentation* rendering_stats_instrumentation,
     SharedBitmapManager* shared_bitmap_manager,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
     TaskGraphRunner* task_graph_runner,
     int id) {
   return make_scoped_ptr(new LayerTreeHostImpl(
-      settings, client, proxy, rendering_stats_instrumentation,
+      settings, client, thread_verifier, rendering_stats_instrumentation,
       shared_bitmap_manager, gpu_memory_buffer_manager, task_graph_runner, id));
 }
 
 LayerTreeHostImpl::LayerTreeHostImpl(
     const LayerTreeSettings& settings,
     LayerTreeHostImplClient* client,
-    Proxy* proxy,
+    ThreadVerifier* thread_verifier,
     RenderingStatsInstrumentation* rendering_stats_instrumentation,
     SharedBitmapManager* shared_bitmap_manager,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
     TaskGraphRunner* task_graph_runner,
     int id)
     : client_(client),
-      proxy_(proxy),
+      thread_verifier_(thread_verifier),
       current_begin_frame_tracker_(BEGINFRAMETRACKER_FROM_HERE),
       output_surface_(nullptr),
       content_is_suitable_for_gpu_rasterization_(true),
       has_gpu_rasterization_trigger_(false),
       use_gpu_rasterization_(false),
       use_msaa_(false),
       gpu_rasterization_status_(GpuRasterizationStatus::OFF_DEVICE),
       tree_resources_for_gpu_rasterization_dirty_(false),
       input_handler_client_(NULL),
       did_lock_scrolling_layer_(false),
       wheel_scrolling_(false),
       scroll_affects_scroll_handler_(false),
       scroll_layer_id_when_mouse_over_scrollbar_(Layer::INVALID_ID),
       tile_priorities_dirty_(false),
       settings_(settings),
       visible_(false),
       cached_managed_memory_policy_(settings.memory_policy_),
-      is_synchronous_single_threaded_(!proxy->HasImplThread() &&
+      is_synchronous_single_threaded_(!thread_verifier->HasImplThread() &&
                                       !settings.single_thread_proxy_scheduler),
-      // Must be initialized after is_synchronous_single_threaded_ and proxy_.
+      // Must be initialized after is_synchronous_single_threaded_ and
+      // thread_verifier_.
       tile_manager_(
           TileManager::Create(this,
                               GetTaskRunner(),
                               is_synchronous_single_threaded_
                                   ? std::numeric_limits<size_t>::max()
                                   : settings.scheduled_raster_task_limit)),
       pinch_gesture_active_(false),
       pinch_gesture_end_should_clear_scrolling_layer_(false),
-      fps_counter_(FrameRateCounter::Create(proxy_->HasImplThread())),
+      fps_counter_(FrameRateCounter::Create(thread_verifier_->HasImplThread())),
       memory_history_(MemoryHistory::Create()),
       debug_rect_history_(DebugRectHistory::Create()),
       texture_mailbox_deleter_(new TextureMailboxDeleter(GetTaskRunner())),
       max_memory_needed_bytes_(0),
       resourceless_software_draw_(false),
       animation_registrar_(),
       rendering_stats_instrumentation_(rendering_stats_instrumentation),
       micro_benchmark_controller_(this),
       shared_bitmap_manager_(shared_bitmap_manager),
       gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
       task_graph_runner_(task_graph_runner),
       id_(id),
       requires_high_res_to_draw_(false),
       is_likely_to_require_a_draw_(false),
       frame_timing_tracker_(FrameTimingTracker::Create(this)) {
   if (settings.use_compositor_animation_timelines) {
     if (settings.accelerated_animation_enabled) {
       animation_host_ = AnimationHost::Create(ThreadInstance::IMPL);
       animation_host_->SetMutatorHostClient(this);
-      animation_host_->SetSupportsScrollAnimations(
-          proxy_->SupportsImplScrolling());
+      animation_host_->SetSupportsScrollAnimations(SupportsImplScrolling());
     }
   } else {
     animation_registrar_ = AnimationRegistrar::Create();
     animation_registrar_->set_supports_scroll_animations(
-        proxy_->SupportsImplScrolling());
+        SupportsImplScrolling());
   }
 
-  DCHECK(proxy_->IsImplThread());
+  DCHECK(thread_verifier_->IsImplThread());
   DidVisibilityChange(this, visible_);
 
   SetDebugState(settings.initial_debug_state);
 
   // LTHI always has an active tree.
   active_tree_ =
       LayerTreeImpl::create(this, new SyncedProperty<ScaleGroup>(),
                             new SyncedTopControls, new SyncedElasticOverscroll);
 
   viewport_ = Viewport::Create(this);
 
   TRACE_EVENT_OBJECT_CREATED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("cc.debug"), "cc::LayerTreeHostImpl", id_);
 
   top_controls_manager_ =
       TopControlsManager::Create(this,
                                  settings.top_controls_show_threshold,
                                  settings.top_controls_hide_threshold);
 }
 
 LayerTreeHostImpl::~LayerTreeHostImpl() {
-  DCHECK(proxy_->IsImplThread());
+  DCHECK(thread_verifier_->IsImplThread());
   TRACE_EVENT0("cc", "LayerTreeHostImpl::~LayerTreeHostImpl()");
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
       TRACE_DISABLED_BY_DEFAULT("cc.debug"), "cc::LayerTreeHostImpl", id_);
 
   if (input_handler_client_) {
     input_handler_client_->WillShutdown();
     input_handler_client_ = NULL;
   }
   if (scroll_elasticity_helper_)
     scroll_elasticity_helper_.reset();
@@ skipping 38 matching lines @@
 
   // Ensure all textures are returned so partial texture updates can happen
   // during the commit.
   // TODO(ericrk): We should not need to ForceReclaimResources when using
   // Impl-side-painting as it doesn't upload during commits. However,
   // Display::Draw currently relies on resource being reclaimed to block drawing
   // between BeginCommit / Swap. See crbug.com/489515.
   if (output_surface_)
     output_surface_->ForceReclaimResources();
 
-  if (!proxy_->CommitToActiveTree())
+  if (!CommitToActiveTree())
     CreatePendingTree();
 }
 
 void LayerTreeHostImpl::CommitComplete() {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::CommitComplete");
 
-  if (proxy_->CommitToActiveTree()) {
+  if (CommitToActiveTree()) {
     // We have to activate animations here or "IsActive()" is true on the layers
     // but the animations aren't activated yet so they get ignored by
     // UpdateDrawProperties.
     ActivateAnimations();
   }
 
   // Start animations before UpdateDrawProperties and PrepareTiles, as they can
   // change the results. When doing commit to the active tree, this must happen
   // after ActivateAnimations() in order for this ticking to be propogated to
   // layers on the active tree.
@@ skipping 14 matching lines @@
   // TODO(vmpstr): Investigate always having PrepareTiles issue
   // NotifyReadyToActivate, instead of handling it here.
   bool did_prepare_tiles = PrepareTiles();
   if (!did_prepare_tiles) {
     NotifyReadyToActivate();
 
     // Ensure we get ReadyToDraw signal even when PrepareTiles not run. This
     // is important for SingleThreadProxy and impl-side painting case. For
     // STP, we commit to active tree and RequiresHighResToDraw, and set
     // Scheduler to wait for ReadyToDraw signal to avoid Checkerboard.
-    if (proxy_->CommitToActiveTree())
+    if (CommitToActiveTree())
       NotifyReadyToDraw();
   }
 
   micro_benchmark_controller_.DidCompleteCommit();
 }
 
 bool LayerTreeHostImpl::CanDraw() const {
   // Note: If you are changing this function or any other function that might
   // affect the result of CanDraw, make sure to call
   // client_->OnCanDrawStateChanged in the proper places and update the
@@ skipping 33 matching lines @@
   if (EvictedUIResourcesExist()) {
     TRACE_EVENT_INSTANT0(
         "cc", "LayerTreeHostImpl::CanDraw UI resources evicted not recreated",
         TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
   return true;
 }
 
 void LayerTreeHostImpl::Animate() {
-  DCHECK(proxy_->IsImplThread());
+  DCHECK(thread_verifier_->IsImplThread());
   base::TimeTicks monotonic_time = CurrentBeginFrameArgs().frame_time;
 
   // mithro(TODO): Enable these checks.
   // DCHECK(!current_begin_frame_tracker_.HasFinished());
   // DCHECK(monotonic_time == current_begin_frame_tracker_.Current().frame_time)
   //  << "Called animate with unknown frame time!?";
 
   if (input_handler_client_) {
     // This animates fling scrolls. But on Android WebView root flings are
     // controlled by the application, so the compositor does not animate them.
@@ skipping 938 matching lines @@
     // destroyed.
     NotifyAllTileTasksCompleted();
 
     CreateTileManagerResources();
     RecreateTreeResources();
   }
 }
 
 void LayerTreeHostImpl::SetTreeActivationCallback(
     const base::Closure& callback) {
-  DCHECK(proxy_->IsImplThread());
+  DCHECK(thread_verifier_->IsImplThread());
   tree_activation_callback_ = callback;
 }
 
 void LayerTreeHostImpl::SetManagedMemoryPolicy(
     const ManagedMemoryPolicy& policy) {
   if (cached_managed_memory_policy_ == policy)
     return;
 
   ManagedMemoryPolicy old_policy = ActualManagedMemoryPolicy();
 
   cached_managed_memory_policy_ = policy;
   ManagedMemoryPolicy actual_policy = ActualManagedMemoryPolicy();
 
   if (old_policy == actual_policy)
     return;
 
-  if (!proxy_->HasImplThread()) {
+  if (!thread_verifier_->HasImplThread()) {
     // In single-thread mode, this can be called on the main thread by
     // GLRenderer::OnMemoryAllocationChanged.
-    DebugScopedSetImplThread impl_thread(proxy_);
+    DebugScopedSetImplThread impl_thread(thread_verifier_);
     UpdateTileManagerMemoryPolicy(actual_policy);
   } else {
-    DCHECK(proxy_->IsImplThread());
+    DCHECK(thread_verifier_->IsImplThread());
     UpdateTileManagerMemoryPolicy(actual_policy);
   }
 
   // If there is already enough memory to draw everything imaginable and the
   // new memory limit does not change this, then do not re-commit. Don't bother
   // skipping commits if this is not visible (commits don't happen when not
   // visible, there will almost always be a commit when this becomes visible).
   bool needs_commit = true;
   if (visible() &&
       actual_policy.bytes_limit_when_visible >= max_memory_needed_bytes_ &&
@@ skipping 557 matching lines @@
         pending_page_scale_animation->use_anchor,
         pending_page_scale_animation->scale,
         pending_page_scale_animation->duration);
   }
   // Activation can change the root scroll offset, so inform the synchronous
   // input handler.
   UpdateRootLayerStateForSynchronousInputHandler();
 }
 
 void LayerTreeHostImpl::SetVisible(bool visible) {
-  DCHECK(proxy_->IsImplThread());
+  DCHECK(thread_verifier_->IsImplThread());
 
   if (visible_ == visible)
     return;
   visible_ = visible;
   DidVisibilityChange(this, visible_);
   UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
 
   // If we just became visible, we have to ensure that we draw high res tiles,
   // to prevent checkerboard/low res flashes.
   if (visible_)
@@ skipping 232 matching lines @@
   if (!output_surface->BindToClient(this)) {
     // Avoid recreating tree resources because we might not have enough
     // information to do this yet (eg. we don't have a TileManager at this
     // point).
     return false;
   }
 
   output_surface_ = output_surface;
   resource_provider_ = ResourceProvider::Create(
       output_surface_, shared_bitmap_manager_, gpu_memory_buffer_manager_,
-      proxy_->blocking_main_thread_task_runner(),
+      thread_verifier_->blocking_main_thread_task_runner(),
       settings_.renderer_settings.highp_threshold_min,
       settings_.renderer_settings.texture_id_allocation_chunk_size,
       settings_.use_image_texture_targets);
 
   CreateAndSetRenderer();
 
   // Since the new renderer may be capable of MSAA, update status here.
   UpdateGpuRasterizationStatus();
 
   CreateTileManagerResources();
@@ skipping 1373 matching lines @@
     int layer_id) const {
   if (active_tree()) {
     LayerAnimationValueProvider* layer = active_tree()->LayerById(layer_id);
     if (layer)
       return layer->ScrollOffsetForAnimation();
   }
 
   return gfx::ScrollOffset();
 }
 
+bool LayerTreeHostImpl::SupportsImplScrolling() const {
+  // Supported in threaded mode.
+  return thread_verifier_->HasImplThread();
+}
+
+bool LayerTreeHostImpl::CommitToActiveTree() const {
+  // In single threaded mode we skip the pending tree and commit directly to the
+  // active tree.
+  return !thread_verifier_->HasImplThread();
+}
+
 }  // namespace cc