Re-land: cc: Implement shared worker contexts.

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 155 matching lines @@
     LayerTreeHostImplClient* client,
     Proxy* proxy,
     RenderingStatsInstrumentation* rendering_stats_instrumentation,
     SharedBitmapManager* shared_bitmap_manager,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
     TaskGraphRunner* task_graph_runner,
     int id)
     : client_(client),
       proxy_(proxy),
       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),
       should_bubble_scrolls_(false),
       wheel_scrolling_(false),
@@ skipping 94 matching lines @@
   recycle_tree_ = nullptr;
   pending_tree_ = nullptr;
   active_tree_ = nullptr;
 
   if (animation_host_) {
     animation_host_->ClearTimelines();
     animation_host_->SetMutatorHostClient(nullptr);
   }
 
   CleanUpTileManager();
+  renderer_ = nullptr;
+  resource_provider_ = nullptr;
+
+  if (output_surface_) {
+    output_surface_->DetachFromClient();
+    output_surface_ = nullptr;
+  }
 }
 
 void LayerTreeHostImpl::BeginMainFrameAborted(CommitEarlyOutReason reason) {
   // If the begin frame data was handled, then scroll and scale set was applied
   // by the main thread, so the active tree needs to be updated as if these sent
   // values were applied and committed.
   if (CommitEarlyOutHandledCommit(reason))
     active_tree_->ApplySentScrollAndScaleDeltasFromAbortedCommit();
 }
 
@@ skipping 1257 matching lines @@
   }
 
   if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE) {
     bool disable_picture_quad_image_filtering =
         IsActivelyScrolling() ||
         (animation_host_ ? animation_host_->NeedsAnimateLayers()
                          : animation_registrar_->needs_animate_layers());
 
     scoped_ptr<SoftwareRenderer> temp_software_renderer =
         SoftwareRenderer::Create(this, &settings_.renderer_settings,
-                                 output_surface_.get(), NULL);
+                                 output_surface_, NULL);
     temp_software_renderer->DrawFrame(&frame->render_passes,
                                       device_scale_factor_,
                                       DeviceViewport(),
                                       DeviceClip(),
                                       disable_picture_quad_image_filtering);
   } else {
     renderer_->DrawFrame(&frame->render_passes,
                          device_scale_factor_,
                          DeviceViewport(),
                          DeviceClip(),
@@ skipping 41 matching lines @@
   return settings_.gpu_rasterization_msaa_sample_count;
 }
 
 bool LayerTreeHostImpl::CanUseGpuRasterization() {
   if (!(output_surface_ && output_surface_->context_provider() &&
         output_surface_->worker_context_provider()))
     return false;
 
   ContextProvider* context_provider =
       output_surface_->worker_context_provider();
-  base::AutoLock context_lock(*context_provider->GetLock());
+  ContextProvider::ScopedContextLock scoped_context(context_provider);
   if (!context_provider->GrContext())
     return false;
 
   return true;
 }
 
 void LayerTreeHostImpl::UpdateGpuRasterizationStatus() {
   bool use_gpu = false;
   bool use_msaa = false;
   bool using_msaa_for_complex_content =
@@ skipping 373 matching lines @@
   if (recycle_tree_)
     recycle_tree_->RecreateResources();
 }
 
 void LayerTreeHostImpl::CreateAndSetRenderer() {
   DCHECK(!renderer_);
   DCHECK(output_surface_);
   DCHECK(resource_provider_);
 
   if (output_surface_->capabilities().delegated_rendering) {
-    renderer_ = DelegatingRenderer::Create(this, &settings_.renderer_settings,
-                                           output_surface_.get(),
-                                           resource_provider_.get());
+    renderer_ =
+        DelegatingRenderer::Create(this, &settings_.renderer_settings,
+                                   output_surface_, resource_provider_.get());
   } else if (output_surface_->context_provider()) {
     renderer_ = GLRenderer::Create(
-        this, &settings_.renderer_settings, output_surface_.get(),
+        this, &settings_.renderer_settings, output_surface_,
         resource_provider_.get(), texture_mailbox_deleter_.get(),
         settings_.renderer_settings.highp_threshold_min);
   } else if (output_surface_->software_device()) {
-    renderer_ = SoftwareRenderer::Create(this, &settings_.renderer_settings,
-                                         output_surface_.get(),
-                                         resource_provider_.get());
+    renderer_ =
+        SoftwareRenderer::Create(this, &settings_.renderer_settings,
+                                 output_surface_, resource_provider_.get());
   }
   DCHECK(renderer_);
 
   renderer_->SetVisible(visible_);
   SetFullRootLayerDamage();
 
   // See note in LayerTreeImpl::UpdateDrawProperties.  Renderer needs to be
   // initialized to get max texture size.  Also, after releasing resources,
   // trees need another update to generate new ones.
   active_tree_->set_needs_update_draw_properties();
@@ skipping 108 matching lines @@
                                              main_frame_events.Pass());
 }
 
 void LayerTreeHostImpl::CleanUpTileManager() {
   tile_manager_->FinishTasksAndCleanUp();
   resource_pool_ = nullptr;
   tile_task_worker_pool_ = nullptr;
   single_thread_synchronous_task_graph_runner_ = nullptr;
 }
 
-bool LayerTreeHostImpl::InitializeRenderer(
-    scoped_ptr<OutputSurface> output_surface) {
+bool LayerTreeHostImpl::InitializeRenderer(OutputSurface* output_surface) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::InitializeRenderer");
 
   // Since we will create a new resource provider, we cannot continue to use
   // the old resources (i.e. render_surfaces and texture IDs). Clear them
   // before we destroy the old resource provider.
   ReleaseTreeResources();
 
   // Note: order is important here.
   renderer_ = nullptr;
   CleanUpTileManager();
   resource_provider_ = nullptr;
-  output_surface_ = nullptr;
+
+  if (output_surface_) {
+    output_surface_->DetachFromClient();
+    output_surface_ = nullptr;
+  }
 
   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.Pass();
+  output_surface_ = output_surface;
   resource_provider_ = ResourceProvider::Create(
-      output_surface_.get(), shared_bitmap_manager_, gpu_memory_buffer_manager_,
+      output_surface_, shared_bitmap_manager_, gpu_memory_buffer_manager_,
       proxy_->blocking_main_thread_task_runner(),
       settings_.renderer_settings.highp_threshold_min,
       settings_.renderer_settings.use_rgba_4444_textures,
       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();
@@ skipping 1407 matching lines @@
   if (active_tree()) {
     LayerAnimationValueProvider* layer = active_tree()->LayerById(layer_id);
     if (layer)
       return layer->ScrollOffsetForAnimation();
   }
 
   return gfx::ScrollOffset();
 }
 
 }  // namespace cc