Move output surface fallback from cc to embedders

content/renderer/gpu/render_widget_compositor.cc

 // Copyright (c) 2013 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 "content/renderer/gpu/render_widget_compositor.h"
 
 #include <limits>
 #include <string>
 
 #include "base/command_line.h"
@@ skipping 391 matching lines @@
   if (cmd->HasSwitch(switches::kDisableLowResTiling))
     settings.create_low_res_tiling = false;
 
   compositor->Initialize(settings);
 
   return compositor.Pass();
 }
 
 RenderWidgetCompositor::RenderWidgetCompositor(RenderWidget* widget,
                                                bool threaded)
-    : threaded_(threaded),
+    : num_failed_recreate_attempts_(0),
+      threaded_(threaded),
       widget_(widget),
-      send_v8_idle_notification_after_commit_(true) {
+      send_v8_idle_notification_after_commit_(true),
+      weak_factory_(this) {
   CommandLine* cmd = CommandLine::ForCurrentProcess();
 
   if (cmd->HasSwitch(switches::kEnableV8IdleNotificationAfterCommit))
     send_v8_idle_notification_after_commit_ = true;
   if (cmd->HasSwitch(switches::kDisableV8IdleNotificationAfterCommit))
     send_v8_idle_notification_after_commit_ = false;
 }
 
 RenderWidgetCompositor::~RenderWidgetCompositor() {}
 
@@ skipping 81 matching lines @@
     const base::Callback<void(scoped_ptr<base::Value>)>& callback) {
   return layer_tree_host_->ScheduleMicroBenchmark(name, value.Pass(), callback);
 }
 
 bool RenderWidgetCompositor::SendMessageToMicroBenchmark(
     int id,
     scoped_ptr<base::Value> value) {
   return layer_tree_host_->SendMessageToMicroBenchmark(id, value.Pass());
 }
 
-void RenderWidgetCompositor::Initialize(cc::LayerTreeSettings settings) {
+void RenderWidgetCompositor::Initialize(const cc::LayerTreeSettings& settings) {
   scoped_refptr<base::MessageLoopProxy> compositor_message_loop_proxy;
   scoped_refptr<base::SingleThreadTaskRunner>
       main_thread_compositor_task_runner(base::MessageLoopProxy::current());
   RenderThreadImpl* render_thread = RenderThreadImpl::current();
   cc::SharedBitmapManager* shared_bitmap_manager = NULL;
   gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager = NULL;
   // render_thread may be NULL in tests.
   if (render_thread) {
     compositor_message_loop_proxy =
         render_thread->compositor_message_loop_proxy();
@@ skipping 309 matching lines @@
 void RenderWidgetCompositor::ApplyViewportDeltas(
     const gfx::Vector2d& scroll_delta,
     float page_scale,
     float top_controls_delta) {
   widget_->webwidget()->applyViewportDeltas(
       scroll_delta,
       page_scale,
       top_controls_delta);
 }
 
-void RenderWidgetCompositor::RequestNewOutputSurface(bool fallback) {
+void RenderWidgetCompositor::RequestNewOutputSurface() {
   // If the host is closing, then no more compositing is possible.  This
   // prevents shutdown races between handling the close message and
   // the CreateOutputSurface task.
   if (widget_->host_closing())
     return;
-  layer_tree_host_->SetOutputSurface(widget_->CreateOutputSurface(fallback));
+
+  bool fallback =
+      num_failed_recreate_attempts_ >= OUTPUT_SURFACE_RETRIES_BEFORE_FALLBACK;
+  scoped_ptr<cc::OutputSurface> surface(widget_->CreateOutputSurface(fallback));
+
+  if (!surface) {
+    DidFailToInitializeOutputSurface();
+    return;
+  }
+
+  layer_tree_host_->SetOutputSurface(surface.Pass());
 }
 
 void RenderWidgetCompositor::DidInitializeOutputSurface() {
+  num_failed_recreate_attempts_ = 0;
+}
+
+void RenderWidgetCompositor::DidFailToInitializeOutputSurface() {
+  ++num_failed_recreate_attempts_;
+  // Tolerate a certain number of recreation failures to work around races
+  // in the output-surface-lost machinery.
+  LOG_IF(FATAL, (num_failed_recreate_attempts_ >= MAX_OUTPUT_SURFACE_RETRIES))
+      << "Failed to create a fallback OutputSurface.";
+
+  base::MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&RenderWidgetCompositor::RequestNewOutputSurface,
+                            weak_factory_.GetWeakPtr()));
 }
 
 void RenderWidgetCompositor::WillCommit() {
   widget_->InstrumentWillComposite();
 }
 
 void RenderWidgetCompositor::DidCommit() {
   DCHECK(!temporary_copy_output_request_);
   if (send_v8_idle_notification_after_commit_) {
     base::TimeDelta idle_time = begin_main_frame_time_ +
@@ skipping 37 matching lines @@
   widget_->OnSwapBuffersAborted();
 }
 
 void RenderWidgetCompositor::RateLimitSharedMainThreadContext() {
   cc::ContextProvider* provider =
       RenderThreadImpl::current()->SharedMainThreadContextProvider().get();
   provider->ContextGL()->RateLimitOffscreenContextCHROMIUM();
 }
 
 }  // namespace content