Remove offscreen compositor contexts.

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 1408 matching lines @@
         GetDrawMode(output_surface_.get()), resource_provider_.get());
   }
 
   if (output_surface_->ForcedDrawToSoftwareDevice()) {
     bool disable_picture_quad_image_filtering =
         IsCurrentlyScrolling() || needs_animate_layers();
 
     scoped_ptr<SoftwareRenderer> temp_software_renderer =
         SoftwareRenderer::Create(this, &settings_, output_surface_.get(), NULL);
     temp_software_renderer->DrawFrame(&frame->render_passes,
-                                      NULL,
                                       device_scale_factor_,
                                       DeviceViewport(),
                                       DeviceClip(),
                                       disable_picture_quad_image_filtering);
   } else {
     renderer_->DrawFrame(&frame->render_passes,
-                         offscreen_context_provider_.get(),
                          device_scale_factor_,
                          DeviceViewport(),
                          DeviceClip(),
                          false);
   }
   // The render passes should be consumed by the renderer.
   DCHECK(frame->render_passes.empty());
   frame->render_passes_by_id.clear();
 
   // The next frame should start by assuming nothing has changed, and changes
@@ skipping 463 matching lines @@
   client_->SetMaxSwapsPendingOnImplThread(max_frames_pending);
 
   resource_provider_ = resource_provider.Pass();
   output_surface_ = output_surface.Pass();
 
   client_->OnCanDrawStateChanged(CanDraw());
 
   return true;
 }
 
-bool LayerTreeHostImpl::DeferredInitialize(
-    scoped_refptr<ContextProvider> offscreen_context_provider) {
+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;
   CreateAndSetRenderer(
       output_surface_.get(), resource_provider_.get(), skip_gl_renderer);
 
-  bool success = true;

[boliu, 2014/04/24 00:28:57]

omg, this is awesome

-  if (offscreen_context_provider.get() &&
-      !offscreen_context_provider->BindToCurrentThread())
-    success = false;
-
-  if (success) {
-    EnforceZeroBudget(false);
-    client_->SetNeedsCommitOnImplThread();
-  } else {
-    if (offscreen_context_provider.get()) {
-      if (offscreen_context_provider->BindToCurrentThread())
-        offscreen_context_provider->VerifyContexts();
-      offscreen_context_provider = NULL;
-    }
-
-    client_->DidLoseOutputSurfaceOnImplThread();
-
-    // If this method fails, the context provider will be dropped from the
-    // output surface and destroyed. But the GLRenderer expects the output
-    // surface to stick around - and hold onto the context3d - as long as it is
-    // alive.
-    // TODO(danakj): Remove the need for this code path: crbug.com/276411
-    renderer_.reset();
-
-    // The resource provider can't stay in GL mode or it tries to clean up GL
-    // stuff, but the context provider is going away on the output surface
-    // which contradicts being in GL mode.
-    // TODO(danakj): Remove the need for this code path: crbug.com/276411
-    resource_provider_->InitializeSoftware();
-  }
-
-  SetOffscreenContextProvider(offscreen_context_provider);
-  return success;
+  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();
   resource_provider_->InitializeSoftware();
 
   bool skip_gl_renderer = true;
   CreateAndSetRenderer(
       output_surface_.get(), resource_provider_.get(), skip_gl_renderer);
 
   EnforceZeroBudget(true);
   CreateAndSetTileManager(resource_provider_.get(),
                           NULL,
                           GetRendererCapabilities().using_map_image,
                           GetRendererCapabilities().allow_rasterize_on_demand);
   DCHECK(tile_manager_);
 
-  SetOffscreenContextProvider(NULL);
-
   client_->SetNeedsCommitOnImplThread();
 }
 
 void LayerTreeHostImpl::SetViewportSize(const gfx::Size& device_viewport_size) {
   if (device_viewport_size == device_viewport_size_)
     return;
 
   if (pending_tree_)
     active_tree_->SetViewportSizeInvalid();
 
@@ skipping 808 matching lines @@
   DCHECK(current);
   current->ReleaseResources();
   if (current->mask_layer())
     SendReleaseResourcesRecursive(current->mask_layer());
   if (current->replica_layer())
     SendReleaseResourcesRecursive(current->replica_layer());
   for (size_t i = 0; i < current->children().size(); ++i)
     SendReleaseResourcesRecursive(current->children()[i]);
 }
 
-void LayerTreeHostImpl::SetOffscreenContextProvider(
-    const scoped_refptr<ContextProvider>& offscreen_context_provider) {
-  if (!offscreen_context_provider.get()) {
-    offscreen_context_provider_ = NULL;
-    return;
-  }
-
-  if (!offscreen_context_provider->BindToCurrentThread()) {
-    offscreen_context_provider_ = NULL;
-    return;
-  }
-
-  offscreen_context_provider_ = offscreen_context_provider;
-}
-
 std::string LayerTreeHostImpl::LayerTreeAsJson() const {
   std::string str;
   if (active_tree_->root_layer()) {
     scoped_ptr<base::Value> json(active_tree_->root_layer()->LayerTreeAsJson());
     base::JSONWriter::WriteWithOptions(
         json.get(), base::JSONWriter::OPTIONS_PRETTY_PRINT, &str);
   }
   return str;
 }
 
@@ skipping 253 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