cc::OutputSurfaceClient::InitializeForGL

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 "base/basictypes.h"
 #include "base/json/json_writer.h"
@@ skipping 1002 matching lines @@
     EnforceManagedMemoryPolicy(ActualManagedMemoryPolicy());
   } else {
     DCHECK(proxy_->IsImplThread());
     EnforceManagedMemoryPolicy(ActualManagedMemoryPolicy());
   }
 
   if (needs_commit)
     client_->SetNeedsCommitOnImplThread();
 }
 
+bool LayerTreeHostImpl::InitializeForGL(
+    scoped_refptr<ContextProvider> offscreen_context_provider) {
+  scoped_ptr<OutputSurface> output_surface = CleanupForRendererInitialization();
+  bool success = DoInitializeRenderer(output_surface.Pass());
+  if (success) {
+    resource_provider_->set_offscreen_context_provider(
+        offscreen_context_provider);
+    client_->DidUpdateCapabilitiesOnImplThread();
+  }
+  return success;
+}
+
 void LayerTreeHostImpl::SetNeedsRedrawRect(gfx::Rect damage_rect) {
   client_->SetNeedsRedrawRectOnImplThread(damage_rect);
 }
 
 void LayerTreeHostImpl::OnVSyncParametersChanged(base::TimeTicks timebase,
                                                  base::TimeDelta interval) {
   client_->OnVSyncParametersChanged(timebase, interval);
 }
 
 void LayerTreeHostImpl::DidVSync(base::TimeTicks frame_time) {
@@ skipping 339 matching lines @@
     return managed_memory_policy_;
 
   ManagedMemoryPolicy actual = managed_memory_policy_;
   actual.priority_cutoff_when_not_visible =
       ManagedMemoryPolicy::CUTOFF_ALLOW_NOTHING;
   actual.priority_cutoff_when_visible =
       ManagedMemoryPolicy::CUTOFF_ALLOW_REQUIRED_ONLY;
   return actual;
 }
 
-bool LayerTreeHostImpl::InitializeRenderer(
-    scoped_ptr<OutputSurface> output_surface) {
+scoped_ptr<OutputSurface>
+LayerTreeHostImpl::CleanupForRendererInitialization() {
   // 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.
   if (active_tree_->root_layer())
     ClearRenderSurfaces();
   if (active_tree_->root_layer())
     SendDidLoseOutputSurfaceRecursive(active_tree_->root_layer());
   if (pending_tree_ && pending_tree_->root_layer())
     SendDidLoseOutputSurfaceRecursive(pending_tree_->root_layer());
   if (recycle_tree_ && recycle_tree_->root_layer())
     SendDidLoseOutputSurfaceRecursive(recycle_tree_->root_layer());
   if (resource_provider_)
     resource_provider_->DidLoseOutputSurface();
 
   // Note: order is important here.
   renderer_.reset();
   tile_manager_.reset();
   resource_provider_.reset();
-  output_surface_.reset();
+  return output_surface_.Pass();
+}
 
-  if (!output_surface->BindToClient(this))
-    return false;
-
+bool LayerTreeHostImpl::DoInitializeRenderer(
+    scoped_ptr<OutputSurface> output_surface) {
   scoped_ptr<ResourceProvider> resource_provider = ResourceProvider::Create(
       output_surface.get(), settings_.highp_threshold_min);
   if (!resource_provider)
     return false;
 
   if (settings_.impl_side_painting) {
     tile_manager_.reset(new TileManager(this,
                                         resource_provider.get(),
                                         settings_.num_raster_threads,
                                         settings_.use_color_estimator,
@@ skipping 27 matching lines @@
 
   // See note in LayerTreeImpl::UpdateDrawProperties.  Renderer needs
   // to be initialized to get max texture size.
   active_tree_->set_needs_update_draw_properties();
   if (pending_tree_)
     pending_tree_->set_needs_update_draw_properties();
 
   return true;
 }
 
+bool LayerTreeHostImpl::InitializeRenderer(
+    scoped_ptr<OutputSurface> output_surface) {
+  scoped_ptr<OutputSurface> old_output_surface =
+      CleanupForRendererInitialization();
+  old_output_surface.reset();
+
+  if (!output_surface->BindToClient(this))
+    return false;
+
+  return DoInitializeRenderer(output_surface.Pass());
+}
+
 void LayerTreeHostImpl::SetViewportSize(gfx::Size device_viewport_size) {
   if (device_viewport_size == device_viewport_size_)
     return;
 
   if (pending_tree_ && device_viewport_size_ != device_viewport_size)
     active_tree_->SetViewportSizeInvalid();
 
   device_viewport_size_ = device_viewport_size;
 
   UpdateMaxScrollOffset();
@@ skipping 723 matching lines @@
 }
 
 void LayerTreeHostImpl::SetDebugState(const LayerTreeDebugState& debug_state) {
   if (debug_state_.continuous_painting != debug_state.continuous_painting)
     paint_time_counter_->ClearHistory();
 
   debug_state_ = debug_state;
 }
 
 }  // namespace cc