Re-land: cc: Examine layers to determine if we're ready to activate.

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 1222 matching lines @@
 
 void LayerTreeHostImpl::DidInitializeVisibleTile() {
   if (client_ && !client_->IsInsideDraw())
     client_->DidInitializeVisibleTileOnImplThread();
 }
 
 void LayerTreeHostImpl::NotifyReadyToActivate() {
   client_->NotifyReadyToActivate();
 }
 
-void LayerTreeHostImpl::NotifyTileInitialized(const Tile* tile) {
-  TRACE_EVENT0("cc", "LayerTreeHostImpl::NotifyTileInitialized");
+void LayerTreeHostImpl::NotifyTileStateChanged(const Tile* tile) {
+  TRACE_EVENT0("cc", "LayerTreeHostImpl::NotifyTileStateChanged");
 
   if (active_tree_) {
     LayerImpl* layer_impl =
         active_tree_->FindActiveTreeLayerById(tile->layer_id());
     if (layer_impl)
-      layer_impl->NotifyTileInitialized(tile);
+      layer_impl->NotifyTileStateChanged(tile);
   }
 
   if (pending_tree_) {
     LayerImpl* layer_impl =
         pending_tree_->FindPendingTreeLayerById(tile->layer_id());
     if (layer_impl)
-      layer_impl->NotifyTileInitialized(tile);
+      layer_impl->NotifyTileStateChanged(tile);
   }
 }
 
 void LayerTreeHostImpl::SetMemoryPolicy(const ManagedMemoryPolicy& policy) {
   SetManagedMemoryPolicy(policy, zero_budget_);
 }
 
 void LayerTreeHostImpl::SetTreeActivationCallback(
     const base::Closure& callback) {
   DCHECK(proxy_->IsImplThread());
@@ skipping 572 matching lines @@
   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) {
+    bool use_one_copy) {
   DCHECK(settings_.impl_side_painting);
   DCHECK(resource_provider);
   DCHECK(proxy_->ImplThreadTaskRunner());
 
   transfer_buffer_memory_limit_ =
       GetMaxTransferBufferUsageBytes(context_provider);
 
   if (use_zero_copy) {
     resource_pool_ =
         ResourcePool::Create(resource_provider,
@@ skipping 27 matching lines @@
         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,
+                          proxy_->ImplThreadTaskRunner(),
                           resource_pool_.get(),
                           raster_worker_pool_->AsRasterizer(),
                           direct_raster_worker_pool_->AsRasterizer(),
-                          allow_rasterize_on_demand,
                           rendering_stats_instrumentation_);
 
   UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
   need_to_update_visible_tiles_before_draw_ = false;
 }
 
 void LayerTreeHostImpl::EnforceZeroBudget(bool zero_budget) {
   SetManagedMemoryPolicy(cached_managed_memory_policy_, zero_budget);
 }
 
@@ skipping 45 matching lines @@
     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);
+    CreateAndSetTileManager(resource_provider.get(),
+                            output_surface->context_provider().get(),
+                            use_zero_copy,
+                            use_one_copy);
   }
 
   // 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 =
@@ skipping 52 matching lines @@
   direct_raster_worker_pool_.reset();
   staging_resource_pool_.reset();
   resource_provider_->InitializeSoftware();
 
   bool skip_gl_renderer = true;
   CreateAndSetRenderer(
       output_surface_.get(), resource_provider_.get(), skip_gl_renderer);
 
   EnforceZeroBudget(true);
   DCHECK(GetRendererCapabilities().using_map_image);
-  CreateAndSetTileManager(resource_provider_.get(),
-                          NULL,
-                          true,
-                          false,
-                          GetRendererCapabilities().allow_rasterize_on_demand);
+  CreateAndSetTileManager(resource_provider_.get(), NULL, true, false);
   DCHECK(tile_manager_);
 
   client_->SetNeedsCommitOnImplThread();
 }
 
 void LayerTreeHostImpl::SetViewportSize(const gfx::Size& device_viewport_size) {
   if (device_viewport_size == device_viewport_size_)
     return;
 
   if (pending_tree_)
@@ skipping 1062 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