Associate an id with the output surface to handle lost contexts

content/browser/renderer_host/render_widget_host_view_aura.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_view_aura.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 280 matching lines @@
         static_cast<const ui::GestureEvent&>(event);
     return gesture.details().touch_points() == 1;
   }
 
   return false;
 }
 
 // Swap ack for the renderer when kCompositeToMailbox is enabled.
 void SendCompositorFrameAck(
     int32 route_id,
+    uint32 output_surface_id,
     int renderer_host_id,
     const gpu::Mailbox& received_mailbox,
     const gfx::Size& received_size,
     bool skip_frame,
     const scoped_refptr<ui::Texture>& texture_to_produce) {
   cc::CompositorFrameAck ack;
   ack.gl_frame_data.reset(new cc::GLFrameData());
   DCHECK(!texture_to_produce.get() || !skip_frame);
   if (texture_to_produce.get()) {
     std::string mailbox_name = texture_to_produce->Produce();
     std::copy(mailbox_name.data(),
               mailbox_name.data() + mailbox_name.length(),
               reinterpret_cast<char*>(ack.gl_frame_data->mailbox.name));
     ack.gl_frame_data->size = texture_to_produce->size();
     ack.gl_frame_data->sync_point =
         content::ImageTransportFactory::GetInstance()->InsertSyncPoint();
   } else if (skip_frame) {
     // Skip the frame, i.e. tell the producer to reuse the same buffer that
     // we just received.
     ack.gl_frame_data->size = received_size;
     ack.gl_frame_data->mailbox = received_mailbox;
   }
 
   RenderWidgetHostImpl::SendSwapCompositorFrameAck(
-      route_id, renderer_host_id, ack);
+      route_id, output_surface_id, renderer_host_id, ack);
 }
 
 void AcknowledgeBufferForGpu(
     int32 route_id,
     int gpu_host_id,
     const std::string& received_mailbox,
     bool skip_frame,
     const scoped_refptr<ui::Texture>& texture_to_produce) {
   AcceleratedSurfaceMsg_BufferPresented_Params ack;
   uint32 sync_point = 0;
@@ skipping 1058 matching lines @@
       params_in_pixel.mailbox_name);
   BuffersSwapped(params_in_pixel.size,
                  gfx::Rect(params_in_pixel.size),
                  params_in_pixel.scale_factor,
                  params_in_pixel.mailbox_name,
                  params_in_pixel.latency_info,
                  ack_callback);
 }
 
 void RenderWidgetHostViewAura::SwapDelegatedFrame(
+    uint32 output_surface_id,
     scoped_ptr<cc::DelegatedFrameData> frame_data,
     float frame_device_scale_factor,
     const ui::LatencyInfo& latency_info) {
   gfx::Size frame_size_in_dip;
   if (!frame_data->render_pass_list.empty()) {
     frame_size_in_dip = gfx::ToFlooredSize(gfx::ScaleSize(
         frame_data->render_pass_list.back()->output_rect.size(),
         1.f/frame_device_scale_factor));
   }
   if (ShouldSkipFrame(frame_size_in_dip)) {
     cc::CompositorFrameAck ack;
     ack.resources.swap(frame_data->resource_list);
     RenderWidgetHostImpl::SendSwapCompositorFrameAck(
-        host_->GetRoutingID(), host_->GetProcess()->GetID(), ack);
+        host_->GetRoutingID(), output_surface_id,
+        host_->GetProcess()->GetID(), ack);
     return;
   }
   window_->layer()->SetDelegatedFrame(frame_data.Pass(), frame_size_in_dip);
   released_front_lock_ = NULL;
   current_frame_size_ = frame_size_in_dip;
   CheckResizeLock();
 
   if (paint_observer_)
     paint_observer_->OnUpdateCompositorContent();
 
   ui::Compositor* compositor = GetCompositor();
   if (!compositor) {
-    SendDelegatedFrameAck();
+    SendDelegatedFrameAck(output_surface_id);
   } else {
     compositor->SetLatencyInfo(latency_info);
     AddOnCommitCallbackAndDisableLocks(
         base::Bind(&RenderWidgetHostViewAura::SendDelegatedFrameAck,
-                   AsWeakPtr()));
+                   AsWeakPtr(),
+                   output_surface_id));
   }
 }
 
-void RenderWidgetHostViewAura::SendDelegatedFrameAck() {
+void RenderWidgetHostViewAura::SendDelegatedFrameAck(uint32 output_surface_id) {
   cc::CompositorFrameAck ack;
   window_->layer()->TakeUnusedResourcesForChildCompositor(&ack.resources);
   RenderWidgetHostImpl::SendSwapCompositorFrameAck(
-      host_->GetRoutingID(), host_->GetProcess()->GetID(), ack);
+      host_->GetRoutingID(), output_surface_id,
+      host_->GetProcess()->GetID(), ack);
 }
 
 void RenderWidgetHostViewAura::SwapSoftwareFrame(
+    uint32 output_surface_id,
     scoped_ptr<cc::SoftwareFrameData> frame_data,
     float frame_device_scale_factor,
     const ui::LatencyInfo& latency_info) {
   const gfx::Size& frame_size = frame_data->size;
   const gfx::Rect& damage_rect = frame_data->damage_rect;
   gfx::Size frame_size_in_dip =
       ConvertSizeToDIP(frame_device_scale_factor, frame_size);
   if (ShouldSkipFrame(frame_size_in_dip)) {
-    SendSoftwareFrameAck(frame_data->id);
+    SendSoftwareFrameAck(output_surface_id, frame_data->id);
     return;
   }
 
   const size_t size_in_bytes = 4 * frame_size.GetArea();
 #ifdef OS_WIN
   scoped_ptr<base::SharedMemory> shared_memory(
       new base::SharedMemory(frame_data->handle, true,
                              host_->GetProcess()->GetHandle()));
 #else
   scoped_ptr<base::SharedMemory> shared_memory(
       new base::SharedMemory(frame_data->handle, true));
 #endif
 
   if (!shared_memory->Map(size_in_bytes)) {
     host_->GetProcess()->ReceivedBadMessage();
     return;
   }
 
   if (last_swapped_surface_size_ != frame_size) {
     DLOG_IF(ERROR, damage_rect != gfx::Rect(frame_size))
         << "Expected full damage rect";
   }
   last_swapped_surface_size_ = frame_size;
   last_swapped_surface_scale_factor_ = frame_device_scale_factor;
 
   base::SharedMemory* shared_memory_raw_ptr = shared_memory.get();
   cc::TextureMailbox::ReleaseCallback callback =
       base::Bind(ReleaseMailbox, Passed(&shared_memory),
                  base::Bind(&RenderWidgetHostViewAura::SendSoftwareFrameAck,
-                            AsWeakPtr(), frame_data->id));
+                            AsWeakPtr(), output_surface_id, frame_data->id));
   current_software_frame_ =
       cc::TextureMailbox(shared_memory_raw_ptr, frame_size, callback);
   DCHECK(current_software_frame_.IsSharedMemory());
   current_frame_size_ = frame_size_in_dip;
 
   released_front_lock_ = NULL;
   CheckResizeLock();
   window_->layer()->SetTextureMailbox(current_software_frame_,
                                       frame_device_scale_factor);
   window_->SchedulePaintInRect(
       ConvertRectToDIP(frame_device_scale_factor, damage_rect));
 
   ui::Compositor* compositor = GetCompositor();
   if (compositor)
     compositor->SetLatencyInfo(latency_info);
   if (paint_observer_)
     paint_observer_->OnUpdateCompositorContent();
 }
 
 void RenderWidgetHostViewAura::SendSoftwareFrameAck(
-    unsigned software_frame_id) {
+    uint32 output_surface_id, unsigned software_frame_id) {
   cc::CompositorFrameAck ack;
   ack.last_software_frame_id = software_frame_id;
   RenderWidgetHostImpl::SendSwapCompositorFrameAck(
-      host_->GetRoutingID(), host_->GetProcess()->GetID(), ack);
+      host_->GetRoutingID(), output_surface_id,
+      host_->GetProcess()->GetID(), ack);
 }
 
 void RenderWidgetHostViewAura::OnSwapCompositorFrame(
+    uint32 output_surface_id,
     scoped_ptr<cc::CompositorFrame> frame) {
   if (frame->delegated_frame_data) {
-    SwapDelegatedFrame(frame->delegated_frame_data.Pass(),
+    SwapDelegatedFrame(output_surface_id,
+                       frame->delegated_frame_data.Pass(),
                        frame->metadata.device_scale_factor,
                        frame->metadata.latency_info);
     return;
   }
 
   if (frame->software_frame_data) {
-    SwapSoftwareFrame(frame->software_frame_data.Pass(),
+    SwapSoftwareFrame(output_surface_id,
+                      frame->software_frame_data.Pass(),
                       frame->metadata.device_scale_factor,
                       frame->metadata.latency_info);
     return;
   }
 
   if (!frame->gl_frame_data || frame->gl_frame_data->mailbox.IsZero())
     return;
 
   BufferPresentedCallback ack_callback = base::Bind(
       &SendCompositorFrameAck,
-      host_->GetRoutingID(), host_->GetProcess()->GetID(),
+      host_->GetRoutingID(), output_surface_id, host_->GetProcess()->GetID(),
       frame->gl_frame_data->mailbox, frame->gl_frame_data->size);
 
   if (!frame->gl_frame_data->sync_point) {
     LOG(ERROR) << "CompositorFrame without sync point. Skipping frame...";
     ack_callback.Run(true, scoped_refptr<ui::Texture>());
     return;
   }
 
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
   factory->WaitSyncPoint(frame->gl_frame_data->sync_point);
@@ skipping 1567 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content