Associate an id with the output surface to handle lost contexts

content/renderer/browser_plugin/browser_plugin_compositing_helper.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/browser_plugin/browser_plugin_compositing_helper.h"
 
 #include "cc/layers/delegated_renderer_layer.h"
 #include "cc/layers/solid_color_layer.h"
 #include "cc/layers/texture_layer.h"
 #include "cc/output/context_provider.h"
 #include "content/common/browser_plugin/browser_plugin_messages.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/renderer/browser_plugin/browser_plugin_manager.h"
 #include "content/renderer/render_thread_impl.h"
 #include "third_party/WebKit/public/platform/WebGraphicsContext3D.h"
 #include "third_party/WebKit/public/web/WebPluginContainer.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "ui/gfx/size_conversions.h"
 #include "webkit/renderer/compositor_bindings/web_layer_impl.h"
 
 namespace content {
 
 BrowserPluginCompositingHelper::SwapBuffersInfo::SwapBuffersInfo()
     : route_id(0),
+      output_surface_id(0),
       host_id(0),
       software_frame_id(0),
       shared_memory(NULL) {
 }
 
 BrowserPluginCompositingHelper::BrowserPluginCompositingHelper(
     WebKit::WebPluginContainer* container,
     BrowserPluginManager* manager,
     int instance_id,
     int host_routing_id)
     : instance_id_(instance_id),
       host_routing_id_(host_routing_id),
       last_route_id_(0),
+      last_output_surface_id_(0),
       last_host_id_(0),
       last_mailbox_valid_(false),
       ack_pending_(true),
       container_(container),
       browser_plugin_manager_(manager) {
 }
 
 BrowserPluginCompositingHelper::~BrowserPluginCompositingHelper() {
 }
 
 void BrowserPluginCompositingHelper::DidCommitCompositorFrame() {
   if (!delegated_layer_.get() || !ack_pending_)
     return;
 
   cc::CompositorFrameAck ack;
   delegated_layer_->TakeUnusedResourcesForChildCompositor(&ack.resources);
 
   browser_plugin_manager_->Send(
       new BrowserPluginHostMsg_CompositorFrameACK(
           host_routing_id_,
           instance_id_,
           last_route_id_,
+          last_output_surface_id_,
           last_host_id_,
           ack));
 
   ack_pending_ = false;
 }
 
 void BrowserPluginCompositingHelper::EnableCompositing(bool enable) {
   if (enable && !background_layer_.get()) {
     background_layer_ = cc::SolidColorLayer::Create();
     background_layer_->SetMasksToBounds(true);
@@ skipping 26 matching lines @@
     bool lost_resource) {
   if (mailbox.type == SOFTWARE_COMPOSITOR_FRAME) {
     delete mailbox.shared_memory;
     mailbox.shared_memory = NULL;
   } else if (lost_resource) {
     // Reset mailbox's name if the resource was lost.
     mailbox.name.SetZero();
   }
 
   // This means the GPU process crashed or guest crashed.
-  if (last_host_id_ != mailbox.host_id || last_route_id_ != mailbox.route_id)
+  if (last_host_id_ != mailbox.host_id ||
+      last_output_surface_id_ != mailbox.output_surface_id ||
+      last_route_id_ != mailbox.route_id)
     return;
 
   // We need to send an ACK to for every buffer sent to us.
   // However, if a buffer is freed up from
   // the compositor in cases like switching back to SW mode without a new
   // buffer arriving, no ACK is needed.
   if (!ack_pending_) {
     last_mailbox_valid_ = false;
     return;
   }
@@ skipping 17 matching lines @@
       ack.gl_frame_data.reset(new cc::GLFrameData());
       ack.gl_frame_data->mailbox = mailbox.name;
       ack.gl_frame_data->size = mailbox.size;
       ack.gl_frame_data->sync_point = sync_point;
 
       browser_plugin_manager_->Send(
          new BrowserPluginHostMsg_CompositorFrameACK(
              host_routing_id_,
              instance_id_,
              mailbox.route_id,
+             mailbox.output_surface_id,
              mailbox.host_id,
              ack));
       break;
     }
     case SOFTWARE_COMPOSITOR_FRAME: {
       cc::CompositorFrameAck ack;
       ack.last_software_frame_id = mailbox.software_frame_id;
 
       browser_plugin_manager_->Send(
          new BrowserPluginHostMsg_CompositorFrameACK(
              host_routing_id_,
              instance_id_,
              mailbox.route_id,
+             mailbox.output_surface_id,
              mailbox.host_id,
              ack));
       break;
     }
   }
 }
 
 void BrowserPluginCompositingHelper::OnContainerDestroy() {
   if (container_)
     container_->setWebLayer(NULL);
   container_ = NULL;
 
   texture_layer_ = NULL;
   delegated_layer_ = NULL;
   background_layer_ = NULL;
   web_layer_.reset();
 }
 
 void BrowserPluginCompositingHelper::OnBuffersSwappedPrivate(
     const SwapBuffersInfo& mailbox,
     unsigned sync_point,
     float device_scale_factor) {
   DCHECK(!delegated_layer_.get());
   // If these mismatch, we are either just starting up, GPU process crashed or
   // guest renderer crashed.
   // In this case, we are communicating with a new image transport
   // surface and must ACK with the new ID's and an empty mailbox.
-  if (last_route_id_ != mailbox.route_id || last_host_id_ != mailbox.host_id)
+  if (last_route_id_ != mailbox.route_id ||
+      last_output_surface_id_ != mailbox.output_surface_id ||
+      last_host_id_ != mailbox.host_id)
     last_mailbox_valid_ = false;
 
   last_route_id_ = mailbox.route_id;
+  last_output_surface_id_ = mailbox.output_surface_id;
   last_host_id_ = mailbox.host_id;
 
   ack_pending_ = true;
   // Browser plugin getting destroyed, do a fast ACK.
   if (!background_layer_.get()) {
     MailboxReleased(mailbox, sync_point, false);
     return;
   }
 
   if (!texture_layer_.get()) {
@@ skipping 53 matching lines @@
     const gfx::Size& size,
     const std::string& mailbox_name,
     int gpu_route_id,
     int gpu_host_id,
     float device_scale_factor) {
   SwapBuffersInfo swap_info;
   swap_info.name.SetName(reinterpret_cast<const int8*>(mailbox_name.data()));
   swap_info.type = TEXTURE_IMAGE_TRANSPORT;
   swap_info.size = size;
   swap_info.route_id = gpu_route_id;
+  swap_info.output_surface_id = 0;
   swap_info.host_id = gpu_host_id;
   OnBuffersSwappedPrivate(swap_info, 0, device_scale_factor);
 }
 
 void BrowserPluginCompositingHelper::OnCompositorFrameSwapped(
     scoped_ptr<cc::CompositorFrame> frame,
     int route_id,
+    uint32 output_surface_id,
     int host_id) {
   if (frame->gl_frame_data) {
     SwapBuffersInfo swap_info;
     swap_info.name = frame->gl_frame_data->mailbox;
     swap_info.type = GL_COMPOSITOR_FRAME;
     swap_info.size = frame->gl_frame_data->size;
     swap_info.route_id = route_id;
+    swap_info.output_surface_id = output_surface_id;
     swap_info.host_id = host_id;
     OnBuffersSwappedPrivate(swap_info,
                             frame->gl_frame_data->sync_point,
                             frame->metadata.device_scale_factor);
     return;
   }
 
   if (frame->software_frame_data) {
     cc::SoftwareFrameData* frame_data = frame->software_frame_data.get();
 
     SwapBuffersInfo swap_info;
     swap_info.type = SOFTWARE_COMPOSITOR_FRAME;
     swap_info.size = frame_data->size;
     swap_info.route_id = route_id;
+    swap_info.output_surface_id = output_surface_id;
     swap_info.host_id = host_id;
     swap_info.software_frame_id = frame_data->id;
 
     scoped_ptr<base::SharedMemory> shared_memory(
         new base::SharedMemory(frame_data->handle, true));
     const size_t size_in_bytes = 4 * frame_data->size.GetArea();
     if (!shared_memory->Map(size_in_bytes)) {
       LOG(ERROR) << "Failed to map shared memory of size "
                  << size_in_bytes;
       // Send ACK right away.
@@ skipping 21 matching lines @@
   if (!frame_data)
     return;
 
   CheckSizeAndAdjustLayerBounds(
       frame_data->render_pass_list.back()->output_rect.size(),
       frame->metadata.device_scale_factor,
       delegated_layer_.get());
 
   delegated_layer_->SetFrameData(frame->delegated_frame_data.Pass());
   last_route_id_ = route_id;
+  last_output_surface_id_ = output_surface_id;
   last_host_id_ = host_id;
   ack_pending_ = true;
 }
 
 void BrowserPluginCompositingHelper::UpdateVisibility(bool visible) {
   if (texture_layer_.get())
     texture_layer_->SetIsDrawable(visible);
   if (delegated_layer_.get())
     delegated_layer_->SetIsDrawable(visible);
 }
 
 }  // namespace content