cc: Allow DeferredInitialize to use DelegatingRenderer

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 554 matching lines @@
   render_passes.push_back(render_pass.Pass());
 }
 
 static DrawMode GetDrawMode(OutputSurface* output_surface) {
   if (output_surface->ForcedDrawToSoftwareDevice()) {
     return DRAW_MODE_RESOURCELESS_SOFTWARE;
   } else if (output_surface->context_provider()) {
     return DRAW_MODE_HARDWARE;
   } else {
     DCHECK_EQ(!output_surface->software_device(),
-              output_surface->capabilities().delegated_rendering);
+              output_surface->capabilities().delegated_rendering &&
+                  !output_surface->capabilities().deferred_gl_initialization)
+        << output_surface->capabilities().delegated_rendering << " "
+        << output_surface->capabilities().deferred_gl_initialization;
     return DRAW_MODE_SOFTWARE;
   }
 }
 
 static void AppendQuadsForLayer(
     RenderPass* target_render_pass,
     LayerImpl* layer,
     const OcclusionTracker<LayerImpl>& occlusion_tracker,
     AppendQuadsData* append_quads_data) {
   QuadCuller quad_culler(target_render_pass, layer, occlusion_tracker);
@@ skipping 1220 matching lines @@
     pending_tree_->ReleaseResources();
   if (recycle_tree_)
     recycle_tree_->ReleaseResources();
 
   EvictAllUIResources();
 }
 
 void LayerTreeHostImpl::CreateAndSetRenderer(
     OutputSurface* output_surface,
     ResourceProvider* resource_provider,
-    bool skip_gl_renderer) {
+    bool force_software_renderer) {
   DCHECK(!renderer_);
-  if (output_surface->capabilities().delegated_rendering) {
+  if (output_surface->capabilities().delegated_rendering &&
+      !force_software_renderer) {

[danakj, 2014/05/20 18:09:51]

Ok I am confused by this change here. Delegated rendering has nothing to do with
hardware vs software, we ship software frames using delegated rendering too. The
only time we couldn't right now is when we want to use SkPicture backed draw
quads (ie resourceless software mode?)

[boliu, 2014/05/20 18:31:49]

Hmm, I think you are right.

The resourceless software mode draw creates its own SoftwareRenderer instance on
the stack for that particular draw, and doesn't need whatever renderer is in
LTHI.

So the SoftwareRenderer created here for webview really is just a place holder
and never used for any draws. And DelegatingRenderer can be created without a
context provider. Then in DeferredInitialize, we tear it down and recreate one
with a context, and everything should just work...

I'll test this now. Assuming it works, this CL will be just DCHECK fixes and
tests, which is just fine with me :)

     renderer_ = DelegatingRenderer::Create(
         this, &settings_, output_surface, resource_provider);
-  } else if (output_surface->context_provider() && !skip_gl_renderer) {
+  } else if (output_surface->context_provider() && !force_software_renderer) {
     renderer_ = GLRenderer::Create(this,
                                    &settings_,
                                    output_surface,
                                    resource_provider,
                                    texture_mailbox_deleter_.get(),
                                    settings_.highp_threshold_min);
   } else if (output_surface->software_device()) {
     renderer_ = SoftwareRenderer::Create(
         this, &settings_, output_surface, resource_provider);
   }
@@ skipping 106 matching lines @@
       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)
     EnforceZeroBudget(true);
 
-  bool skip_gl_renderer = false;
+  bool force_software_renderer =
+      output_surface->capabilities().deferred_gl_initialization;
   CreateAndSetRenderer(
-      output_surface.get(), resource_provider.get(), skip_gl_renderer);
+      output_surface.get(), resource_provider.get(), force_software_renderer);
 
   transfer_buffer_memory_limit_ =
       GetMaxTransferBufferUsageBytes(output_surface->context_provider().get());
 
   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) &&
@@ skipping 47 matching lines @@
 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;
+  bool force_software_renderer = false;
   CreateAndSetRenderer(
-      output_surface_.get(), resource_provider_.get(), skip_gl_renderer);
+      output_surface_.get(), resource_provider_.get(), force_software_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();
   resource_provider_->InitializeSoftware();
 
-  bool skip_gl_renderer = true;
+  bool force_software_renderer = true;
   CreateAndSetRenderer(
-      output_surface_.get(), resource_provider_.get(), skip_gl_renderer);
+      output_surface_.get(), resource_provider_.get(), force_software_renderer);
 
   EnforceZeroBudget(true);
   DCHECK(GetRendererCapabilities().using_map_image);
   CreateAndSetTileManager(resource_provider_.get(),
                           NULL,
                           true,
                           false,
                           GetRendererCapabilities().allow_rasterize_on_demand);
   DCHECK(tile_manager_);
 
@@ skipping 1070 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