cc: Get rid of rasterizer delegate.

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 "base/basictypes.h"
@@ skipping 97 matching lines @@
     return GL_TEXTURE_2D;
 
   if (context_provider->ContextCapabilities().gpu.egl_image_external)
     return GL_TEXTURE_EXTERNAL_OES;
   if (context_provider->ContextCapabilities().gpu.texture_rectangle)
     return GL_TEXTURE_RECTANGLE_ARB;
 
   return GL_TEXTURE_2D;
 }
 
+bool UseZeroCopyTextureUpload(cc::LayerTreeHostImpl* host_impl) {

[reveman, 2014/05/21 04:17:06]

Either make these two functions member functions if they take a LTHI as
parameter or pass settings and renderer capabilities to them. Or keep the
temporary variables used before this patch which I think was fine.

[alokp, 2014/05/21 05:24:43]

Done.

+  // Note: we use zero-copy by default when the renderer is using
+  // shared memory resources.
+  return (host_impl->settings().use_zero_copy ||
+          host_impl->GetRendererCapabilities().using_shared_memory_resources) &&
+         host_impl->GetRendererCapabilities().using_map_image;
+}
+
+bool UseOneCopyTextureUpload(cc::LayerTreeHostImpl* host_impl) {
+  // Sync query support is required by one-copy rasterizer.
+  return host_impl->settings().use_one_copy &&
+         host_impl->GetRendererCapabilities().using_map_image &&
+         host_impl->resource_provider()->use_sync_query();
+}
+
 }  // namespace
 
 namespace cc {
 
 class LayerTreeHostImplTimeSourceAdapter : public TimeSourceClient {
  public:
   static scoped_ptr<LayerTreeHostImplTimeSourceAdapter> Create(
       LayerTreeHostImpl* layer_tree_host_impl,
       scoped_refptr<DelayBasedTimeSource> time_source) {
     return make_scoped_ptr(
@@ skipping 167 matching lines @@
   // made a contract with our animation controllers that the registrar
   // will outlive them, and we must make good.
   if (recycle_tree_)
     recycle_tree_->Shutdown();
   if (pending_tree_)
     pending_tree_->Shutdown();
   active_tree_->Shutdown();
   recycle_tree_.reset();
   pending_tree_.reset();
   active_tree_.reset();
-  tile_manager_.reset();
-  resource_pool_.reset();
-  raster_worker_pool_.reset();
-  direct_raster_worker_pool_.reset();
-  staging_resource_pool_.reset();
+  DestroyTileManager();
 }
 
 void LayerTreeHostImpl::BeginMainFrameAborted(bool did_handle) {
   // 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 (did_handle) {
     active_tree_->ApplySentScrollAndScaleDeltasFromAbortedCommit();
     active_tree_->ResetContentsTexturesPurged();
   }
@@ skipping 1201 matching lines @@
   return renderer_ && renderer_->IsContextLost();
 }
 
 void LayerTreeHostImpl::SetUseGpuRasterization(bool use_gpu) {
   if (use_gpu == use_gpu_rasterization_)
     return;
 
   use_gpu_rasterization_ = use_gpu;
   ReleaseTreeResources();
 
+  // Replace existing tile manager with another one that uses appropriate
+  // rasterizer.
+  if (tile_manager_) {
+    DestroyTileManager();
+    CreateAndSetTileManager(output_surface_->context_provider().get());
+  }
+
   // We have released tilings for both active and pending tree.
   // We would not have any content to draw until the pending tree is activated.
   // Prevent the active tree from drawing until activation.
   active_tree_->SetRequiresHighResToDraw();
 }
 
 const RendererCapabilitiesImpl&
 LayerTreeHostImpl::GetRendererCapabilities() const {
   return renderer_->Capabilities();
 }
@@ skipping 273 matching lines @@
 void LayerTreeHostImpl::ReleaseTreeResources() {
   active_tree_->ReleaseResources();
   if (pending_tree_)
     pending_tree_->ReleaseResources();
   if (recycle_tree_)
     recycle_tree_->ReleaseResources();
 
   EvictAllUIResources();
 }
 
-void LayerTreeHostImpl::CreateAndSetRenderer(
-    OutputSurface* output_surface,
-    ResourceProvider* resource_provider,
-    bool skip_gl_renderer) {
+void LayerTreeHostImpl::CreateAndSetRenderer(bool skip_gl_renderer) {
   DCHECK(!renderer_);
-  if (output_surface->capabilities().delegated_rendering) {
+  DCHECK(output_surface_);
+  DCHECK(resource_provider_);
+
+  if (output_surface_->capabilities().delegated_rendering) {
     renderer_ = DelegatingRenderer::Create(
-        this, &settings_, output_surface, resource_provider);
-  } else if (output_surface->context_provider() && !skip_gl_renderer) {
+        this, &settings_, output_surface_.get(), resource_provider_.get());
+  } else if (output_surface_->context_provider() && !skip_gl_renderer) {
     renderer_ = GLRenderer::Create(this,
                                    &settings_,
-                                   output_surface,
-                                   resource_provider,
+                                   output_surface_.get(),
+                                   resource_provider_.get(),
                                    texture_mailbox_deleter_.get(),
                                    settings_.highp_threshold_min);
-  } else if (output_surface->software_device()) {
+  } else if (output_surface_->software_device()) {
     renderer_ = SoftwareRenderer::Create(
-        this, &settings_, output_surface, resource_provider);
+        this, &settings_, output_surface_.get(), 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();
   if (pending_tree_)
     pending_tree_->set_needs_update_draw_properties();
   client_->UpdateRendererCapabilitiesOnImplThread();
 }
 
 void LayerTreeHostImpl::CreateAndSetTileManager(
-    ResourceProvider* resource_provider,
-    ContextProvider* context_provider,
-    bool use_zero_copy,
-    bool use_one_copy,
-    bool allow_rasterize_on_demand) {
+    ContextProvider* context_provider) {
+  DCHECK(!tile_manager_);
   DCHECK(settings_.impl_side_painting);
-  DCHECK(resource_provider);
+  DCHECK(resource_provider_);
   DCHECK(proxy_->ImplThreadTaskRunner());
 
   transfer_buffer_memory_limit_ =
       GetMaxTransferBufferUsageBytes(context_provider);
 
-  if (use_zero_copy) {
+  if (use_gpu_rasterization_ && context_provider) {
     resource_pool_ =
-        ResourcePool::Create(resource_provider,
+        ResourcePool::Create(resource_provider_.get(),
+                             GL_TEXTURE_2D,
+                             resource_provider_->best_texture_format());
+
+    raster_worker_pool_ =
+        DirectRasterWorkerPool::Create(proxy_->ImplThreadTaskRunner(),
+                                       resource_provider_.get(),
+                                       context_provider);
+
+  } else if (UseZeroCopyTextureUpload(this)) {
+    resource_pool_ =
+        ResourcePool::Create(resource_provider_.get(),
                              GetMapImageTextureTarget(context_provider),
-                             resource_provider->best_texture_format());
+                             resource_provider_->best_texture_format());
+
     raster_worker_pool_ =
         ImageRasterWorkerPool::Create(proxy_->ImplThreadTaskRunner(),
                                       RasterWorkerPool::GetTaskGraphRunner(),
-                                      resource_provider);
-  } else if (use_one_copy) {
+                                      resource_provider_.get());
+  } else if (UseOneCopyTextureUpload(this)) {
     // We need to create a staging resource pool when using copy rasterizer.
     staging_resource_pool_ =
-        ResourcePool::Create(resource_provider,
+        ResourcePool::Create(resource_provider_.get(),
                              GetMapImageTextureTarget(context_provider),
-                             resource_provider->best_texture_format());
+                             resource_provider_->best_texture_format());
     resource_pool_ =
-        ResourcePool::Create(resource_provider,
+        ResourcePool::Create(resource_provider_.get(),
                              GL_TEXTURE_2D,
-                             resource_provider->best_texture_format());
+                             resource_provider_->best_texture_format());
 
     raster_worker_pool_ = ImageCopyRasterWorkerPool::Create(
         proxy_->ImplThreadTaskRunner(),
         RasterWorkerPool::GetTaskGraphRunner(),
-        resource_provider,
+        resource_provider_.get(),
         staging_resource_pool_.get());
   } else {
+    resource_pool_ = ResourcePool::Create(
+        resource_provider_.get(),
+        GL_TEXTURE_2D,
+        resource_provider_->memory_efficient_texture_format());
+
     raster_worker_pool_ = PixelBufferRasterWorkerPool::Create(
         proxy_->ImplThreadTaskRunner(),
         RasterWorkerPool::GetTaskGraphRunner(),
-        resource_provider,
+        resource_provider_.get(),
         transfer_buffer_memory_limit_);
-    resource_pool_ = ResourcePool::Create(
-        resource_provider,
-        GL_TEXTURE_2D,
-        resource_provider->memory_efficient_texture_format());
   }
-  direct_raster_worker_pool_ = DirectRasterWorkerPool::Create(
-      proxy_->ImplThreadTaskRunner(), resource_provider, context_provider);
+
   tile_manager_ =
       TileManager::Create(this,
                           resource_pool_.get(),
                           raster_worker_pool_->AsRasterizer(),
-                          direct_raster_worker_pool_->AsRasterizer(),
-                          allow_rasterize_on_demand,
+                          GetRendererCapabilities().allow_rasterize_on_demand,
                           rendering_stats_instrumentation_);
+  DCHECK(tile_manager_);

[reveman, 2014/05/21 04:17:06]

I don't think it's necessary to check that ::Create succeeds as the only thing
that should allow it to fail is oom.

[alokp, 2014/05/21 05:24:43]

Done.

 
   UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
   need_to_update_visible_tiles_before_draw_ = false;
 }
 
+void LayerTreeHostImpl::DestroyTileManager() {
+  tile_manager_.reset();
+  resource_pool_.reset();
+  staging_resource_pool_.reset();
+  raster_worker_pool_.reset();
+}
+
 void LayerTreeHostImpl::EnforceZeroBudget(bool zero_budget) {
   SetManagedMemoryPolicy(cached_managed_memory_policy_, zero_budget);
 }
 
 bool LayerTreeHostImpl::InitializeRenderer(
     scoped_ptr<OutputSurface> output_surface) {
 #if DCHECK_IS_ON
   DCHECK(!renderer_ || did_lose_called_);
 #endif
 
   // 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_.reset();
-  tile_manager_.reset();
-  resource_pool_.reset();
-  staging_resource_pool_.reset();
-  raster_worker_pool_.reset();
-  direct_raster_worker_pool_.reset();
+  DestroyTileManager();
   resource_provider_.reset();
   output_surface_.reset();
 
   if (!output_surface->BindToClient(this))
     return false;
 
-  scoped_ptr<ResourceProvider> resource_provider =
-      ResourceProvider::Create(output_surface.get(),
+  output_surface_ = output_surface.Pass();
+  resource_provider_ =
+      ResourceProvider::Create(output_surface_.get(),
                                shared_bitmap_manager_,
                                settings_.highp_threshold_min,
                                settings_.use_rgba_4444_textures,
                                settings_.texture_id_allocation_chunk_size,
                                settings_.use_distance_field_text);
 
-  if (output_surface->capabilities().deferred_gl_initialization)
+  if (output_surface_->capabilities().deferred_gl_initialization)
     EnforceZeroBudget(true);
 
   bool skip_gl_renderer = false;
-  CreateAndSetRenderer(
-      output_surface.get(), resource_provider.get(), skip_gl_renderer);
+  CreateAndSetRenderer(skip_gl_renderer);
 
+  ContextProvider* context_provider = output_surface_->context_provider().get();
   transfer_buffer_memory_limit_ =
-      GetMaxTransferBufferUsageBytes(output_surface->context_provider().get());
+      GetMaxTransferBufferUsageBytes(context_provider);
 
-  if (settings_.impl_side_painting) {
-    // Note: we use zero-copy rasterizer by default when the renderer is using
-    // shared memory resources.
-    bool use_zero_copy =
-        (settings_.use_zero_copy ||
-         GetRendererCapabilities().using_shared_memory_resources) &&
-        GetRendererCapabilities().using_map_image;
-
-    // Sync query support is required by one-copy rasterizer.
-    bool use_one_copy = settings_.use_one_copy &&
-                        GetRendererCapabilities().using_map_image &&
-                        resource_provider->use_sync_query();
-
-    CreateAndSetTileManager(
-        resource_provider.get(),
-        output_surface->context_provider().get(),
-        use_zero_copy,
-        use_one_copy,
-        GetRendererCapabilities().allow_rasterize_on_demand);
-  }
+  if (settings_.impl_side_painting)
+    CreateAndSetTileManager(context_provider);
 
   // Initialize vsync parameters to sane values.
   const base::TimeDelta display_refresh_interval =
       base::TimeDelta::FromMicroseconds(base::Time::kMicrosecondsPerSecond /
                                         settings_.refresh_rate);
   CommitVSyncParameters(base::TimeTicks(), display_refresh_interval);
 
   // TODO(brianderson): Don't use a hard-coded parent draw time.
   base::TimeDelta parent_draw_time =
-      output_surface->capabilities().adjust_deadline_for_parent
+      output_surface_->capabilities().adjust_deadline_for_parent
           ? BeginFrameArgs::DefaultDeadlineAdjustment()
           : base::TimeDelta();
   client_->SetEstimatedParentDrawTime(parent_draw_time);
 
-  int max_frames_pending =
-      output_surface->capabilities().max_frames_pending;
+  int max_frames_pending = output_surface_->capabilities().max_frames_pending;
   if (max_frames_pending <= 0)
     max_frames_pending = OutputSurface::DEFAULT_MAX_FRAMES_PENDING;
   client_->SetMaxSwapsPendingOnImplThread(max_frames_pending);
-
-  resource_provider_ = resource_provider.Pass();
-  output_surface_ = output_surface.Pass();
-
   client_->OnCanDrawStateChanged(CanDraw());
 
   return true;
 }
 
 void LayerTreeHostImpl::CommitVSyncParameters(base::TimeTicks timebase,
                                               base::TimeDelta interval) {
   client_->CommitVSyncParameters(timebase, interval);
 }
 
 void LayerTreeHostImpl::DeferredInitialize() {
   DCHECK(output_surface_->capabilities().deferred_gl_initialization);
   DCHECK(settings_.impl_side_painting);
   DCHECK(output_surface_->context_provider());
 
   ReleaseTreeResources();
   renderer_.reset();
 
   resource_provider_->InitializeGL();
 
   bool skip_gl_renderer = false;
-  CreateAndSetRenderer(
-      output_surface_.get(), resource_provider_.get(), skip_gl_renderer);
+  CreateAndSetRenderer(skip_gl_renderer);
 
   EnforceZeroBudget(false);
   client_->SetNeedsCommitOnImplThread();
 }
 
 void LayerTreeHostImpl::ReleaseGL() {
   DCHECK(output_surface_->capabilities().deferred_gl_initialization);
   DCHECK(settings_.impl_side_painting);
   DCHECK(output_surface_->context_provider());
 
   ReleaseTreeResources();
   renderer_.reset();
-  tile_manager_.reset();
-  resource_pool_.reset();
-  raster_worker_pool_.reset();
-  direct_raster_worker_pool_.reset();
-  staging_resource_pool_.reset();
+  DestroyTileManager();
   resource_provider_->InitializeSoftware();
 
   bool skip_gl_renderer = true;
-  CreateAndSetRenderer(
-      output_surface_.get(), resource_provider_.get(), skip_gl_renderer);
+  CreateAndSetRenderer(skip_gl_renderer);
 
   EnforceZeroBudget(true);
-  DCHECK(GetRendererCapabilities().using_map_image);
-  CreateAndSetTileManager(resource_provider_.get(),
-                          NULL,
-                          true,
-                          false,
-                          GetRendererCapabilities().allow_rasterize_on_demand);
-  DCHECK(tile_manager_);
+  DCHECK(UseZeroCopyTextureUpload(this));

[reveman, 2014/05/21 04:17:06]

I don't think this DCHECK makes sense here. You're not doing anything in this
function anymore that rely on this returning true.

[alokp, 2014/05/21 05:24:43]

Done.

+  CreateAndSetTileManager(NULL);
 
   client_->SetNeedsCommitOnImplThread();
 }
 
 void LayerTreeHostImpl::SetViewportSize(const gfx::Size& device_viewport_size) {
   if (device_viewport_size == device_viewport_size_)
     return;
 
   if (pending_tree_)
     active_tree_->SetViewportSizeInvalid();
@@ skipping 1061 matching lines @@
   swap_promise_monitor_.erase(monitor);
 }
 
 void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfSetNeedsRedraw() {
   std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
   for (; it != swap_promise_monitor_.end(); it++)
     (*it)->OnSetNeedsRedrawOnImpl();
 }
 
 }  // namespace cc