cc: Get rid of rasterizer delegate.

It is not needed anymore now that we do not support hybrid rasterization. Gpu-rasterization flag is per page instead of per layer.

BUG=367200

Review URL: https://codereview.chromium.org/296453009

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@272335 0039d316-1c4b-4281-b951-d872f2087c98

cc/cc.gyp

@@ -374,8 +374,6 @@
         'resources/raster_worker_pool.h',
         'resources/rasterizer.cc',
         'resources/rasterizer.h',
-        'resources/rasterizer_delegate.cc',
-        'resources/rasterizer_delegate.h',
         'resources/release_callback.h',
         'resources/resource.cc',
         'resources/resource.h',

cc/resources/rasterizer_delegate.cc

-// Copyright 2014 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/resources/rasterizer_delegate.h"
-
-#include "base/debug/trace_event.h"
-
-namespace cc {
-
-RasterizerDelegate::RasterizerDelegate(RasterizerClient* client,
-                                       Rasterizer** rasterizers,
-                                       size_t num_rasterizers)
-    : client_(client),
-      rasterizers_(rasterizers, rasterizers + num_rasterizers),
-      did_finish_running_tasks_pending_count_(0u),
-      did_finish_running_tasks_required_for_activation_pending_count_(0u) {
-  DCHECK(client_);
-  for (RasterizerVector::iterator it = rasterizers_.begin();
-       it != rasterizers_.end();
-       ++it)
-    (*it)->SetClient(this);
-}
-
-RasterizerDelegate::~RasterizerDelegate() {}
-
-// static
-scoped_ptr<RasterizerDelegate> RasterizerDelegate::Create(
-    RasterizerClient* client,
-    Rasterizer** rasterizers,
-    size_t num_rasterizers) {
-  return make_scoped_ptr(
-      new RasterizerDelegate(client, rasterizers, num_rasterizers));
-}
-
-void RasterizerDelegate::Shutdown() {
-  for (RasterizerVector::iterator it = rasterizers_.begin();
-       it != rasterizers_.end();
-       ++it)
-    (*it)->Shutdown();
-}
-
-void RasterizerDelegate::ScheduleTasks(RasterTaskQueue* queue) {
-  for (size_t i = 0; i < rasterizers_.size(); ++i)
-    rasterizers_[i]->ScheduleTasks(&queue[i]);
-
-  did_finish_running_tasks_pending_count_ = rasterizers_.size();
-  did_finish_running_tasks_required_for_activation_pending_count_ =
-      rasterizers_.size();
-}
-
-void RasterizerDelegate::CheckForCompletedTasks() {
-  for (RasterizerVector::iterator it = rasterizers_.begin();
-       it != rasterizers_.end();
-       ++it)
-    (*it)->CheckForCompletedTasks();
-}
-
-bool RasterizerDelegate::ShouldForceTasksRequiredForActivationToComplete()
-    const {
-  return client_->ShouldForceTasksRequiredForActivationToComplete();
-}
-
-void RasterizerDelegate::DidFinishRunningTasks() {
-  TRACE_EVENT1("cc",
-               "RasterizerDelegate::DidFinishRunningTasks",
-               "pending_count",
-               did_finish_running_tasks_pending_count_);
-
-  DCHECK_LT(0u, did_finish_running_tasks_pending_count_);
-  if (--did_finish_running_tasks_pending_count_)
-    return;
-  client_->DidFinishRunningTasks();
-}
-
-void RasterizerDelegate::DidFinishRunningTasksRequiredForActivation() {
-  TRACE_EVENT1("cc",
-               "RasterizerDelegate::DidFinishRunningTasksRequiredForActivation",
-               "pending_count",
-               did_finish_running_tasks_required_for_activation_pending_count_);
-
-  DCHECK_LT(0u,
-            did_finish_running_tasks_required_for_activation_pending_count_);
-  if (--did_finish_running_tasks_required_for_activation_pending_count_)
-    return;
-  client_->DidFinishRunningTasksRequiredForActivation();
-}
-
-}  // namespace cc

cc/resources/rasterizer_delegate.h

-// Copyright 2014 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.
-
-#ifndef CC_RESOURCES_RASTERIZER_DELEGATE_H_
-#define CC_RESOURCES_RASTERIZER_DELEGATE_H_
-
-#include <vector>
-
-#include "cc/resources/rasterizer.h"
-
-namespace cc {
-
-class RasterizerDelegate : public RasterizerClient {
- public:
-  virtual ~RasterizerDelegate();
-
-  static scoped_ptr<RasterizerDelegate> Create(RasterizerClient* client,
-                                               Rasterizer** rasterizers,
-                                               size_t num_rasterizers);
-
-  void SetClient(RasterizerClient* client);
-  void Shutdown();
-  void ScheduleTasks(RasterTaskQueue* queue);
-  void CheckForCompletedTasks();
-
-  // Overriden from RasterizerClient:
-  virtual bool ShouldForceTasksRequiredForActivationToComplete() const OVERRIDE;
-  virtual void DidFinishRunningTasks() OVERRIDE;
-  virtual void DidFinishRunningTasksRequiredForActivation() OVERRIDE;
-
- private:
-  RasterizerDelegate(RasterizerClient* client,
-                     Rasterizer** rasterizers,
-                     size_t num_rasterizers);
-
-  RasterizerClient* client_;
-  typedef std::vector<Rasterizer*> RasterizerVector;
-  RasterizerVector rasterizers_;
-  size_t did_finish_running_tasks_pending_count_;
-  size_t did_finish_running_tasks_required_for_activation_pending_count_;
-};
-
-}  // namespace cc
-
-#endif  // CC_RESOURCES_RASTERIZER_DELEGATE_H_

cc/resources/tile_manager.cc

@@ -367,13 +367,11 @@ scoped_ptr<TileManager> TileManager::Create(
     TileManagerClient* client,
     ResourcePool* resource_pool,
     Rasterizer* rasterizer,
-    Rasterizer* gpu_rasterizer,
     bool use_rasterize_on_demand,
     RenderingStatsInstrumentation* rendering_stats_instrumentation) {
   return make_scoped_ptr(new TileManager(client,
                                          resource_pool,
                                          rasterizer,
-                                         gpu_rasterizer,
                                          use_rasterize_on_demand,
                                          rendering_stats_instrumentation));
 }
@@ -382,11 +380,11 @@ TileManager::TileManager(
     TileManagerClient* client,
     ResourcePool* resource_pool,
     Rasterizer* rasterizer,
-    Rasterizer* gpu_rasterizer,
     bool use_rasterize_on_demand,
     RenderingStatsInstrumentation* rendering_stats_instrumentation)
     : client_(client),
       resource_pool_(resource_pool),
+      rasterizer_(rasterizer),
       prioritized_tiles_dirty_(false),
       all_tiles_that_need_to_be_rasterized_have_memory_(true),
       all_tiles_required_for_activation_have_memory_(true),
@@ -399,12 +397,7 @@ TileManager::TileManager(
       did_initialize_visible_tile_(false),
       did_check_for_completed_tasks_since_last_schedule_tasks_(true),
       use_rasterize_on_demand_(use_rasterize_on_demand) {
-  Rasterizer* rasterizers[NUM_RASTERIZER_TYPES] = {
-      rasterizer,      // RASTERIZER_TYPE_DEFAULT
-      gpu_rasterizer,  // RASTERIZER_TYPE_GPU
-  };
-  rasterizer_delegate_ =
-      RasterizerDelegate::Create(this, rasterizers, arraysize(rasterizers));
+  rasterizer_->SetClient(this);
 }
 
 TileManager::~TileManager() {
@@ -415,14 +408,14 @@ TileManager::~TileManager() {
   CleanUpReleasedTiles();
   DCHECK_EQ(0u, tiles_.size());
 
-  RasterTaskQueue empty[NUM_RASTERIZER_TYPES];
-  rasterizer_delegate_->ScheduleTasks(empty);
+  RasterTaskQueue empty;
+  rasterizer_->ScheduleTasks(&empty);
   orphan_raster_tasks_.clear();
 
   // This should finish all pending tasks and release any uninitialized
   // resources.
-  rasterizer_delegate_->Shutdown();
-  rasterizer_delegate_->CheckForCompletedTasks();
+  rasterizer_->Shutdown();
+  rasterizer_->CheckForCompletedTasks();
 
   DCHECK_EQ(0u, bytes_releasable_);
   DCHECK_EQ(0u, resources_releasable_);
@@ -500,7 +493,7 @@ void TileManager::DidFinishRunningTasks() {
       !memory_usage_above_limit)
     return;
 
-  rasterizer_delegate_->CheckForCompletedTasks();
+  rasterizer_->CheckForCompletedTasks();
   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
   TileVector tiles_that_need_to_be_rasterized;
@@ -707,7 +700,7 @@ void TileManager::ManageTiles(const GlobalStateThatImpactsTilePriority& state) {
   // We need to call CheckForCompletedTasks() once in-between each call
   // to ScheduleTasks() to prevent canceled tasks from being scheduled.
   if (!did_check_for_completed_tasks_since_last_schedule_tasks_) {
-    rasterizer_delegate_->CheckForCompletedTasks();
+    rasterizer_->CheckForCompletedTasks();
     did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
   }
 
@@ -736,7 +729,7 @@ void TileManager::ManageTiles(const GlobalStateThatImpactsTilePriority& state) {
 bool TileManager::UpdateVisibleTiles() {
   TRACE_EVENT0("cc", "TileManager::UpdateVisibleTiles");
 
-  rasterizer_delegate_->CheckForCompletedTasks();
+  rasterizer_->CheckForCompletedTasks();
   did_check_for_completed_tasks_since_last_schedule_tasks_ = true;
 
   TRACE_EVENT_INSTANT1(
@@ -1013,8 +1006,7 @@ void TileManager::ScheduleTasks(
 
   DCHECK(did_check_for_completed_tasks_since_last_schedule_tasks_);
 
-  for (size_t i = 0; i < NUM_RASTERIZER_TYPES; ++i)
-    raster_queue_[i].Reset();
+  raster_queue_.Reset();
 
   // Build a new task queue containing all task currently needed. Tasks
   // are added in order of priority, highest priority task first.
@@ -1032,12 +1024,9 @@ void TileManager::ScheduleTasks(
     if (!tile_version.raster_task_)
       tile_version.raster_task_ = CreateRasterTask(tile);
 
-    size_t pool_type = tile->use_gpu_rasterization() ? RASTERIZER_TYPE_GPU
-                                                     : RASTERIZER_TYPE_DEFAULT;
-
-    raster_queue_[pool_type].items.push_back(RasterTaskQueue::Item(
+    raster_queue_.items.push_back(RasterTaskQueue::Item(
         tile_version.raster_task_.get(), tile->required_for_activation()));
-    raster_queue_[pool_type].required_for_activation_count +=
+    raster_queue_.required_for_activation_count +=
         tile->required_for_activation();
   }
 
@@ -1048,7 +1037,7 @@ void TileManager::ScheduleTasks(
   // Schedule running of |raster_tasks_|. This replaces any previously
   // scheduled tasks and effectively cancels all tasks not present
   // in |raster_tasks_|.
-  rasterizer_delegate_->ScheduleTasks(raster_queue_);
+  rasterizer_->ScheduleTasks(&raster_queue_);
 
   // It's now safe to clean up orphan tasks as raster worker pool is not
   // allowed to keep around unreferenced raster tasks after ScheduleTasks() has
@@ -1633,11 +1622,9 @@ bool TileManager::EvictionTileIterator::EvictionOrderComparator::operator()(
   return a_priority.IsHigherPriorityThan(b_priority);
 }
 
-void TileManager::SetRasterizersForTesting(Rasterizer* rasterizer,
-                                           Rasterizer* gpu_rasterizer) {
-  Rasterizer* rasterizers[2] = {rasterizer, gpu_rasterizer};
-  rasterizer_delegate_ =
-      RasterizerDelegate::Create(this, rasterizers, arraysize(rasterizers));
+void TileManager::SetRasterizerForTesting(Rasterizer* rasterizer) {
+  rasterizer_ = rasterizer;
+  rasterizer_->SetClient(this);
 }
 
 }  // namespace cc

cc/resources/tile_manager.h

@@ -22,12 +22,10 @@
 #include "cc/resources/picture_pile_impl.h"
 #include "cc/resources/prioritized_tile_set.h"
 #include "cc/resources/rasterizer.h"
-#include "cc/resources/rasterizer_delegate.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/resources/tile.h"
 
 namespace cc {
-class RasterizerDelegate;
 class ResourceProvider;
 
 class CC_EXPORT TileManagerClient {
@@ -158,7 +156,6 @@ class CC_EXPORT TileManager : public RasterizerClient,
       TileManagerClient* client,
       ResourcePool* resource_pool,
       Rasterizer* rasterizer,
-      Rasterizer* gpu_rasterizer,
       bool use_rasterize_on_demand,
       RenderingStatsInstrumentation* rendering_stats_instrumentation);
   virtual ~TileManager();
@@ -225,8 +222,7 @@ class CC_EXPORT TileManager : public RasterizerClient,
     }
   }
 
-  void SetRasterizersForTesting(Rasterizer* rasterizer,
-                                Rasterizer* gpu_rasterizer);
+  void SetRasterizerForTesting(Rasterizer* rasterizer);
 
   void CleanUpReleasedTilesForTesting() { CleanUpReleasedTiles(); }
 
@@ -234,7 +230,6 @@ class CC_EXPORT TileManager : public RasterizerClient,
   TileManager(TileManagerClient* client,
               ResourcePool* resource_pool,
               Rasterizer* rasterizer,
-              Rasterizer* gpu_rasterizer,
               bool use_rasterize_on_demand,
               RenderingStatsInstrumentation* rendering_stats_instrumentation);
 
@@ -264,12 +259,6 @@ class CC_EXPORT TileManager : public RasterizerClient,
   void GetTilesWithAssignedBins(PrioritizedTileSet* tiles);
 
  private:
-  enum RasterizerType {
-    RASTERIZER_TYPE_DEFAULT,
-    RASTERIZER_TYPE_GPU,
-    NUM_RASTERIZER_TYPES
-  };
-
   void OnImageDecodeTaskCompleted(int layer_id,
                                   SkPixelRef* pixel_ref,
                                   bool was_canceled);
@@ -296,7 +285,7 @@ class CC_EXPORT TileManager : public RasterizerClient,
 
   TileManagerClient* client_;
   ResourcePool* resource_pool_;
-  scoped_ptr<RasterizerDelegate> rasterizer_delegate_;
+  Rasterizer* rasterizer_;
   GlobalStateThatImpactsTilePriority global_state_;
 
   typedef base::hash_map<Tile::Id, Tile*> TileMap;
@@ -338,8 +327,8 @@ class CC_EXPORT TileManager : public RasterizerClient,
 
   ResourceFormat resource_format_;
 
-  // Queues used when scheduling raster tasks.
-  RasterTaskQueue raster_queue_[NUM_RASTERIZER_TYPES];
+  // Queue used when scheduling raster tasks.
+  RasterTaskQueue raster_queue_;
 
   std::vector<scoped_refptr<RasterTask> > orphan_raster_tasks_;
 

cc/resources/tile_manager_perftest.cc

@@ -116,8 +116,7 @@ class TileManagerPerfTest : public testing::Test, public TileManagerClient {
   virtual void InitializeRenderer() {
     host_impl_.InitializeRenderer(
         FakeOutputSurface::Create3d().PassAs<OutputSurface>());
-    tile_manager()->SetRasterizersForTesting(g_fake_rasterizer.Pointer(),
-                                             g_fake_rasterizer.Pointer());
+    tile_manager()->SetRasterizerForTesting(g_fake_rasterizer.Pointer());
   }
 
   void SetupDefaultTrees(const gfx::Size& layer_bounds) {

cc/test/fake_tile_manager.cc

@@ -65,7 +65,6 @@ FakeTileManager::FakeTileManager(TileManagerClient* client)
     : TileManager(client,
                   NULL,
                   g_fake_rasterizer.Pointer(),
-                  g_fake_rasterizer.Pointer(),
                   true,
                   NULL) {}
 
@@ -74,7 +73,6 @@ FakeTileManager::FakeTileManager(TileManagerClient* client,
     : TileManager(client,
                   resource_pool,
                   g_fake_rasterizer.Pointer(),
-                  g_fake_rasterizer.Pointer(),
                   true,
                   NULL) {}
 
@@ -84,7 +82,6 @@ FakeTileManager::FakeTileManager(TileManagerClient* client,
     : TileManager(client,
                   resource_pool,
                   g_fake_rasterizer.Pointer(),
-                  g_fake_rasterizer.Pointer(),
                   allow_on_demand_raster,
                   NULL) {}
 

cc/trees/layer_tree_host_impl.h

@@ -486,16 +486,15 @@ class CC_EXPORT LayerTreeHostImpl
   Proxy* proxy_;
 
  private:
-  void CreateAndSetRenderer(OutputSurface* output_surface,
-                            ResourceProvider* resource_provider);
-  void CreateAndSetTileManager(ResourceProvider* resource_provider,
-                               ContextProvider* context_provider,
-                               bool use_zero_copy,
-                               bool use_one_copy,
-                               bool allow_rasterize_on_demand);
+  void CreateAndSetRenderer();
+  void CreateAndSetTileManager();
+  void DestroyTileManager();
   void ReleaseTreeResources();
   void EnforceZeroBudget(bool zero_budget);
 
+  bool UseZeroCopyTextureUpload() const;
+  bool UseOneCopyTextureUpload() const;
+
   void ScrollViewportBy(gfx::Vector2dF scroll_delta);
   void AnimatePageScale(base::TimeTicks monotonic_time);
   void AnimateScrollbars(base::TimeTicks monotonic_time);
@@ -564,7 +563,6 @@ class CC_EXPORT LayerTreeHostImpl
   scoped_ptr<TileManager> tile_manager_;
   bool use_gpu_rasterization_;
   scoped_ptr<RasterWorkerPool> raster_worker_pool_;
-  scoped_ptr<RasterWorkerPool> direct_raster_worker_pool_;
   scoped_ptr<ResourcePool> resource_pool_;
   scoped_ptr<ResourcePool> staging_resource_pool_;
   scoped_ptr<Renderer> renderer_;