Associate an id with the output surface to handle lost contexts

content/browser/renderer_host/render_widget_host_view_android.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_android.h"
 
 #include <android/bitmap.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 41 matching lines @@
       ImageTransportFactoryAndroid::GetInstance()->InsertSyncPoint();
   AcceleratedSurfaceMsg_BufferPresented_Params ack_params;
   ack_params.mailbox_name = return_mailbox;
   ack_params.sync_point = sync_point;
   RenderWidgetHostImpl::AcknowledgeBufferPresent(
       route_id, gpu_host_id, ack_params);
 }
 
 void InsertSyncPointAndAckForCompositor(
     int renderer_host_id,
+    uint32 output_surface_id,
     int route_id,
     const gpu::Mailbox& return_mailbox,
     const gfx::Size return_size) {
   cc::CompositorFrameAck ack;
   ack.gl_frame_data.reset(new cc::GLFrameData());
   if (!return_mailbox.IsZero()) {
     ack.gl_frame_data->mailbox = return_mailbox;
     ack.gl_frame_data->size = return_size;
     ack.gl_frame_data->sync_point =
         ImageTransportFactoryAndroid::GetInstance()->InsertSyncPoint();
   }
   RenderWidgetHostImpl::SendSwapCompositorFrameAck(
-      route_id, renderer_host_id, ack);
+      route_id, output_surface_id, renderer_host_id, ack);
 }
 
 }  // anonymous namespace
 
 RenderWidgetHostViewAndroid::RenderWidgetHostViewAndroid(
     RenderWidgetHostImpl* widget_host,
     ContentViewCoreImpl* content_view_core)
     : host_(widget_host),
       needs_begin_frame_(false),
       are_layers_attached_(true),
@@ skipping 469 matching lines @@
   return new TouchSmoothScrollGestureAndroid(
       pixels_to_scroll,
       GetRenderWidgetHost(),
       content_view_core_->CreateSmoothScroller(
           scroll_down, mouse_event_x, mouse_event_y));
 }
 
 void RenderWidgetHostViewAndroid::OnAcceleratedCompositingStateChange() {
 }
 
-void RenderWidgetHostViewAndroid::SendDelegatedFrameAck() {
+void RenderWidgetHostViewAndroid::SendDelegatedFrameAck(
+    uint32 output_surface_id) {
   cc::CompositorFrameAck ack;
   delegated_renderer_layer_->TakeUnusedResourcesForChildCompositor(
       &ack.resources);
   RenderWidgetHostImpl::SendSwapCompositorFrameAck(
-      host_->GetRoutingID(), host_->GetProcess()->GetID(), ack);
+      host_->GetRoutingID(), output_surface_id,
+      host_->GetProcess()->GetID(), ack);
 }
 
 void RenderWidgetHostViewAndroid::SwapDelegatedFrame(
+    uint32 output_surface_id,
     scoped_ptr<cc::DelegatedFrameData> frame_data) {
   bool has_frame = frame_data.get() && !frame_data->render_pass_list.empty();
 
   if (has_frame) {
     delegated_renderer_layer_->SetFrameData(frame_data.Pass());
     delegated_renderer_layer_->SetDisplaySize(texture_size_in_layer_);
     layer_->SetIsDrawable(true);
   }
   layer_->SetBounds(content_size_in_layer_);
   layer_->SetNeedsDisplay();
 
   base::Closure ack_callback =
       base::Bind(&RenderWidgetHostViewAndroid::SendDelegatedFrameAck,
-                 weak_ptr_factory_.GetWeakPtr());
+                 weak_ptr_factory_.GetWeakPtr(),
+                 output_surface_id);
 
   if (host_->is_hidden())
     ack_callback.Run();
   else
     ack_callbacks_.push(ack_callback);
 }
 
 void RenderWidgetHostViewAndroid::ComputeContentsSize(
     const cc::CompositorFrameMetadata& frame_metadata) {
   // Calculate the content size.  This should be 0 if the texture_size is 0.
   gfx::Vector2dF offset;
   if (texture_size_in_layer_.GetArea() > 0)
     offset = frame_metadata.location_bar_content_translation;
   offset.set_y(offset.y() + frame_metadata.overdraw_bottom_height);
   offset.Scale(frame_metadata.device_scale_factor);
   content_size_in_layer_ =
       gfx::Size(texture_size_in_layer_.width() - offset.x(),
                 texture_size_in_layer_.height() - offset.y());
   // Content size changes should be reflected in associated animation effects.
   UpdateAnimationSize(frame_metadata);
 }
 
 void RenderWidgetHostViewAndroid::OnSwapCompositorFrame(
+    uint32 output_surface_id,
     scoped_ptr<cc::CompositorFrame> frame) {
   // Always let ContentViewCore know about the new frame first, so it can decide
   // to schedule a Draw immediately when it sees the texture layer invalidation.
   UpdateContentViewCoreFrameMetadata(frame->metadata);
 
   if (frame->delegated_frame_data) {
     if (!frame->delegated_frame_data->render_pass_list.empty()) {
       texture_size_in_layer_ = frame->delegated_frame_data->render_pass_list
           .back()->output_rect.size();
     }
     ComputeContentsSize(frame->metadata);
 
-    SwapDelegatedFrame(frame->delegated_frame_data.Pass());
+    SwapDelegatedFrame(output_surface_id, frame->delegated_frame_data.Pass());
     return;
   }
 
   if (!frame->gl_frame_data || frame->gl_frame_data->mailbox.IsZero())
     return;
 
   base::Closure callback = base::Bind(&InsertSyncPointAndAckForCompositor,
                                       host_->GetProcess()->GetID(),
+                                      output_surface_id,
                                       host_->GetRoutingID(),
                                       current_mailbox_,
                                       texture_size_in_layer_);
   ImageTransportFactoryAndroid::GetInstance()->WaitSyncPoint(
       frame->gl_frame_data->sync_point);
 
   texture_size_in_layer_ = frame->gl_frame_data->size;
   ComputeContentsSize(frame->metadata);
 
   if (layer_->layer_tree_host())
@@ skipping 483 matching lines @@
 // RenderWidgetHostView, public:
 
 // static
 RenderWidgetHostView*
 RenderWidgetHostView::CreateViewForWidget(RenderWidgetHost* widget) {
   RenderWidgetHostImpl* rwhi = RenderWidgetHostImpl::From(widget);
   return new RenderWidgetHostViewAndroid(rwhi, NULL);
 }
 
 } // namespace content