Initialize the Display's renderer when the Display is initialized.

cc/surfaces/display.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/surfaces/display.h"
 
 #include <stddef.h>
 
 #include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 70 matching lines @@
   // they are ready to receive a BeginFrameSource.
   if (begin_frame_source_) {
     surface_manager_->RegisterBeginFrameSource(begin_frame_source_.get(),
                                                compositor_surface_namespace_);
   }
 
   bool ok = output_surface_->BindToClient(this);
   // The context given to the Display's OutputSurface should already be
   // initialized, so Bind can not fail.
   DCHECK(ok);
+  InitializeRenderer();
 }
 
 void Display::SetSurfaceId(const SurfaceId& id, float device_scale_factor) {
   DCHECK_EQ(id.client_id(), compositor_surface_namespace_);
   if (current_surface_id_ == id && device_scale_factor_ == device_scale_factor)
     return;
 
   TRACE_EVENT0("cc", "Display::SetSurfaceId");
   current_surface_id_ = id;
   device_scale_factor_ = device_scale_factor;
@@ skipping 43 matching lines @@
 
   if (aggregator_) {
     aggregator_->set_output_is_secure(secure);
     // Force a redraw.
     if (!current_surface_id_.is_null())
       aggregator_->SetFullDamageForSurface(current_surface_id_);
   }
 }
 
 void Display::InitializeRenderer() {
-  if (resource_provider_)
-    return;
-
-  std::unique_ptr<ResourceProvider> resource_provider(new ResourceProvider(
+  resource_provider_.reset(new ResourceProvider(
       output_surface_->context_provider(), bitmap_manager_,
       gpu_memory_buffer_manager_, nullptr, settings_.highp_threshold_min,
       settings_.texture_id_allocation_chunk_size,
       output_surface_->capabilities().delegated_sync_points_required,
       settings_.use_gpu_memory_buffer_resources,
       settings_.buffer_to_texture_target_map));
 
   if (output_surface_->context_provider()) {
     DCHECK(texture_mailbox_deleter_);
-    std::unique_ptr<GLRenderer> renderer = GLRenderer::Create(
-        this, &settings_, output_surface_.get(), resource_provider.get(),
+    renderer_ = base::MakeUnique<GLRenderer>(
+        this, &settings_, output_surface_.get(), resource_provider_.get(),
         texture_mailbox_deleter_.get(), settings_.highp_threshold_min);
-    if (!renderer)
-      return;
-    renderer_ = std::move(renderer);
   } else if (output_surface_->vulkan_context_provider()) {
 #if defined(ENABLE_VULKAN)
     DCHECK(texture_mailbox_deleter_);
-    std::unique_ptr<VulkanRenderer> renderer = VulkanRenderer::Create(
-        this, &settings_, output_surface_.get(), resource_provider.get(),
+    renderer_ = base::MakeUnique<VulkanRenderer>(
+        this, &settings_, output_surface_.get(), resource_provider_.get(),
         texture_mailbox_deleter_.get(), settings_.highp_threshold_min);
-    if (!renderer)
-      return;
-    renderer_ = std::move(renderer);
 #else
     NOTREACHED();
 #endif
   } else {
-    std::unique_ptr<SoftwareRenderer> renderer = SoftwareRenderer::Create(
-        this, &settings_, output_surface_.get(), resource_provider.get());
-    if (!renderer)
-      return;
+    auto renderer = base::MakeUnique<SoftwareRenderer>(
+        this, &settings_, output_surface_.get(), resource_provider_.get());
     software_renderer_ = renderer.get();
     renderer_ = std::move(renderer);
   }
 
   renderer_->SetEnlargePassTextureAmount(enlarge_texture_amount_);
 
-  resource_provider_ = std::move(resource_provider);
   // TODO(jbauman): Outputting an incomplete quad list doesn't work when using
   // overlays.
   bool output_partial_list = renderer_->Capabilities().using_partial_swap &&
                              !output_surface_->GetOverlayCandidateValidator();
   aggregator_.reset(new SurfaceAggregator(
       surface_manager_, resource_provider_.get(), output_partial_list));
   aggregator_->set_output_is_secure(output_is_secure_);
 }
 
 void Display::DidLoseOutputSurface() {
@@ skipping 13 matching lines @@
 }
 
 bool Display::DrawAndSwap() {
   TRACE_EVENT0("cc", "Display::DrawAndSwap");
 
   if (current_surface_id_.is_null()) {
     TRACE_EVENT_INSTANT0("cc", "No root surface.", TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
-  InitializeRenderer();
   if (!output_surface_) {
     TRACE_EVENT_INSTANT0("cc", "No output surface", TRACE_EVENT_SCOPE_THREAD);
     return false;
   }
 
   CompositorFrame frame = aggregator_->Aggregate(current_surface_id_);
   if (!frame.delegated_frame_data) {
     TRACE_EVENT_INSTANT0("cc", "Empty aggregated frame.",
                          TRACE_EVENT_SCOPE_THREAD);
     return false;
@@ skipping 186 matching lines @@
 
   if (surface_id == current_surface_id_)
     UpdateRootSurfaceResourcesLocked();
 }
 
 const SurfaceId& Display::CurrentSurfaceId() {
   return current_surface_id_;
 }
 
 }  // namespace cc