Associate an id with the output surface to handle lost contexts

content/renderer/render_widget.cc

 // Copyright (c) 2012 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/render_widget.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 208 matching lines @@
       text_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
       popup_type_(popup_type),
       pending_window_rect_count_(0),
       suppress_next_char_events_(false),
       is_accelerated_compositing_active_(false),
       animation_update_pending_(false),
       invalidation_task_posted_(false),
       screen_info_(screen_info),
       device_scale_factor_(screen_info_.deviceScaleFactor),
       is_threaded_compositing_enabled_(false),
+      next_output_surface_id_(0),
       weak_ptr_factory_(this) {
   if (!swapped_out)
     RenderProcess::current()->AddRefProcess();
   DCHECK(RenderThread::Get());
   has_disable_gpu_vsync_switch_ = CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDisableGpuVsync);
   is_threaded_compositing_enabled_ =
       CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableThreadedCompositing);
 
@@ skipping 391 matching lines @@
 bool RenderWidget::ForceCompositingModeEnabled() {
   return false;
 }
 
 scoped_ptr<cc::OutputSurface> RenderWidget::CreateOutputSurface() {
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 
 #if defined(OS_ANDROID)
    if (SynchronousCompositorFactory* factory =
        SynchronousCompositorFactory::GetInstance()) {
     return factory->CreateOutputSurface(routing_id());

[piman, 2013/07/16 04:24:30]

note: I believe we don't need to pass the output_surface_id here, because we're
in process and everything is synchronous anyway. If we do, let me know.

   }
 #endif
 
+  uint32 output_surface_id = next_output_surface_id_++;
+
   if (command_line.HasSwitch(switches::kEnableSoftwareCompositingGLAdapter)) {
       return scoped_ptr<cc::OutputSurface>(
-          new CompositorOutputSurface(routing_id(), NULL,
+          new CompositorOutputSurface(routing_id(), output_surface_id, NULL,
               new CompositorSoftwareOutputDevice(), true));
   }
 
   // Explicitly disable antialiasing for the compositor. As of the time of
   // this writing, the only platform that supported antialiasing for the
   // compositor was Mac OS X, because the on-screen OpenGL context creation
   // code paths on Windows and Linux didn't yet have multisampling support.
   // Mac OS X essentially always behaves as though it's rendering offscreen.
   // Multisampling has a heavy cost especially on devices with relatively low
   // fill rate like most notebooks, and the Mac implementation would need to
@@ skipping 10 matching lines @@
     attributes.stencil = true;
   WebGraphicsContext3DCommandBufferImpl* context =
       CreateGraphicsContext3D(attributes);
   if (!context)
     return scoped_ptr<cc::OutputSurface>();
 
   if (command_line.HasSwitch(switches::kEnableDelegatedRenderer) &&
       !command_line.HasSwitch(switches::kDisableDelegatedRenderer)) {
     DCHECK(is_threaded_compositing_enabled_);
     return scoped_ptr<cc::OutputSurface>(
-        new DelegatedCompositorOutputSurface(routing_id(), context, NULL));
+        new DelegatedCompositorOutputSurface(routing_id(), output_surface_id,
+                                             context, NULL));
   }
   if (command_line.HasSwitch(cc::switches::kCompositeToMailbox)) {
     DCHECK(is_threaded_compositing_enabled_);
     return scoped_ptr<cc::OutputSurface>(
-        new MailboxOutputSurface(routing_id(), context, NULL));
+        new MailboxOutputSurface(routing_id(), output_surface_id,
+                                 context, NULL));
   }
   return scoped_ptr<cc::OutputSurface>(
-      new CompositorOutputSurface(routing_id(), context, NULL, false));
+      new CompositorOutputSurface(routing_id(), output_surface_id,
+                                  context, NULL, false));
 }
 
 void RenderWidget::OnViewContextSwapBuffersAborted() {
   TRACE_EVENT0("renderer", "RenderWidget::OnSwapBuffersAborted");
   while (!updates_pending_swap_.empty()) {
     ViewHostMsg_UpdateRect* msg = updates_pending_swap_.front();
     updates_pending_swap_.pop_front();
     // msg can be NULL if the swap doesn't correspond to an DoDeferredUpdate
     // compositing pass, hence doesn't require an UpdateRect message.
     if (msg)
@@ skipping 1785 matching lines @@
 
   if (!context->InitializeWithDefaultBufferSizes(
           attributes,
           false /* bind generates resources */,
           CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE))
     return NULL;
   return context.release();
 }
 
 }  // namespace content