Associate an id with the output surface to handle lost contexts

content/browser/renderer_host/render_widget_host_impl.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/browser/renderer_host/render_widget_host_impl.h"
 
 #include <math.h>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 1774 matching lines @@
   view_->DidReceiveRendererFrame();
 }
 #endif  // OS_MACOSX
 
 bool RenderWidgetHostImpl::OnSwapCompositorFrame(
     const IPC::Message& message) {
   ViewHostMsg_SwapCompositorFrame::Param param;
   if (!ViewHostMsg_SwapCompositorFrame::Read(&message, &param))
     return false;
   scoped_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
-  param.a.AssignTo(frame.get());
+  uint32 output_surface_id = param.a;
+  param.b.AssignTo(frame.get());
 
   if (view_) {
-    view_->OnSwapCompositorFrame(frame.Pass());
+    view_->OnSwapCompositorFrame(output_surface_id, frame.Pass());
     view_->DidReceiveRendererFrame();
   } else {
     cc::CompositorFrameAck ack;
     if (frame->gl_frame_data) {
       ack.gl_frame_data = frame->gl_frame_data.Pass();
       ack.gl_frame_data->sync_point = 0;
     } else if (frame->delegated_frame_data) {
       ack.resources.swap(frame->delegated_frame_data->resource_list);
     } else if (frame->software_frame_data) {
       ack.last_software_frame_id = frame->software_frame_data->id;
     }
-    SendSwapCompositorFrameAck(routing_id_, process_->GetID(), ack);
+    SendSwapCompositorFrameAck(routing_id_, process_->GetID(),
+                               output_surface_id,  ack);
   }
   return true;
 }
 
 void RenderWidgetHostImpl::OnOverscrolled(
     gfx::Vector2dF accumulated_overscroll,
     gfx::Vector2dF current_fling_velocity) {
   if (view_)
     view_->OnOverscrolled(accumulated_overscroll, current_fling_velocity);
 }
@@ skipping 728 matching lines @@
     const AcceleratedSurfaceMsg_BufferPresented_Params& params) {
   GpuProcessHostUIShim* ui_shim = GpuProcessHostUIShim::FromID(gpu_host_id);
   if (ui_shim) {
     ui_shim->Send(new AcceleratedSurfaceMsg_BufferPresented(route_id,
                                                             params));
   }
 }
 
 // static
 void RenderWidgetHostImpl::SendSwapCompositorFrameAck(
-    int32 route_id, int renderer_host_id, const cc::CompositorFrameAck& ack) {
+    int32 route_id,
+    uint32 output_surface_id,
+    int renderer_host_id,
+    const cc::CompositorFrameAck& ack) {
   RenderProcessHost* host = RenderProcessHost::FromID(renderer_host_id);
-  if (host)
-    host->Send(new ViewMsg_SwapCompositorFrameAck(route_id, ack));
+  if (!host)
+    return;
+  host->Send(new ViewMsg_SwapCompositorFrameAck(
+      route_id, output_surface_id, ack));
 }
 
 void RenderWidgetHostImpl::AcknowledgeSwapBuffersToRenderer() {
   if (!is_threaded_compositing_enabled_)
     Send(new ViewMsg_SwapBuffers_ACK(routing_id_));
 }
 
 #if defined(USE_AURA)
 
 void RenderWidgetHostImpl::ParentChanged(gfx::NativeViewId new_parent) {
@@ skipping 110 matching lines @@
     int process_id = (b->first.second >> 32) & 0xffffffff;
     RenderWidgetHost* rwh =
         RenderWidgetHost::FromID(process_id, routing_id);
     if (!rwh)
       continue;
     RenderWidgetHostImpl::From(rwh)->FrameSwapped(latency_info);
   }
 }
 
 }  // namespace content