aura: Allow delegated frames to be used by more than one impl layer.

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/basictypes.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
+#include "cc/layers/delegated_frame_provider.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_ack.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/resources/texture_mailbox.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
 #include "content/browser/accessibility/browser_accessibility_state_impl.h"
 #include "content/browser/aura/compositor_resize_lock.h"
 #include "content/browser/gpu/compositor_util.h"
@@ skipping 1438 matching lines @@
   }
 
   if (output_surface_id != last_output_surface_id_) {
     // Resource ids are scoped by the output surface.
     // If the originating output surface doesn't match the last one, it
     // indicates the renderer's output surface may have been recreated, in which
     // case we should recreate the DelegatedRendererLayer, to avoid matching
     // resources from the old one with resources from the new one which would
     // have the same id. Changing the layer to showing painted content destroys
     // the DelegatedRendererLayer.
-    // TODO(danakj): Lose and return all resources in the delegated layer first.
     window_->layer()->SetShowPaintedContent();
+
+    // TODO(danakj): Lose all resources and send them back here, such as:
+    // resource_collection_->LoseAllResources();
+    // SendReturnedDelegatedResources(last_output_surface_id_);
+
+    // Drop the cc::DelegatedFrameResourceCollection so that we will not return
+    // any resources from the old output surface with the new output surface id.

[piman, 2013/10/04 23:42:25]

I wonder if we should have the DelegatedFrameResourceCollection manage the
output_surface_id somehow? When we receive the resources and create the DFRC, we
know exactly what surface id we're supposed to return them to. Then in
SendDelegatedFrameAck we could check the surface id the resource_collection_
corresponds to, and only return the resources through the SwapCompositorFrameAck
if it matches the surface id. If not, we can send the ReclaimCompositorResources
message (maybe? Or dropping resources is probably ok).

[danakj, 2013/10/07 21:57:39]

Hm, if I'm understanding your suggestion, we'll have replaced the
resource_collection_ just below here anyway. So we'd need to keep around the old
collection just to wait for the resources to come back, but the child won't want
them. That's why I think we should just force lose them here so we can tell the
child immediately and keep this simpler with only one resource collection alive.

[piman, 2013/10/08 03:38:08]

Ok. The thing I'm kinda worried is below in SendDelegatedFrameAck, I'm not sure
what guarantees the resources we take back come from the right
output_surface_id. But that's not specific to this patch, so we can iterate
later if it proves to be an issue.

+    frame_provider_.reset();
+    resource_collection_.reset();
     last_output_surface_id_ = output_surface_id;
   }
   if (frame_size.IsEmpty()) {
-    // TODO(danakj): Return all resources in the delegated layer somehow.
+    DCHECK_EQ(0u, frame_data->resource_list.size());
     window_->layer()->SetShowPaintedContent();
   } else {
-    window_->layer()->SetDelegatedFrame(frame_data.Pass(), frame_size_in_dip);
+    if (!resource_collection_)

[piman, 2013/10/04 23:42:25]

nit: needs {}

[danakj, 2013/10/07 21:57:39]

Done.

+      resource_collection_.reset(
+          new cc::DelegatedFrameResourceCollection(this));
+    if (!frame_provider_ || frame_size != frame_provider_->frame_size()) {
+      frame_provider_.reset(new cc::DelegatedFrameProvider(
+          resource_collection_.get(), frame_data.Pass()));
+      window_->layer()->SetShowDelegatedContent(frame_provider_.get(),
+                                                frame_size_in_dip);
+    } else {
+      frame_provider_->SetFrameData(frame_data.Pass());
+    }
   }
   released_front_lock_ = NULL;
   current_frame_size_ = frame_size_in_dip;
   CheckResizeLock();
 
   if (paint_observer_)
     paint_observer_->OnUpdateCompositorContent();
   window_->SchedulePaintInRect(damage_rect_in_dip);
 
   ui::Compositor* compositor = GetCompositor();
   if (!compositor) {
     SendDelegatedFrameAck(output_surface_id);
   } else {
     compositor->SetLatencyInfo(latency_info);
     AddOnCommitCallbackAndDisableLocks(
         base::Bind(&RenderWidgetHostViewAura::SendDelegatedFrameAck,
                    AsWeakPtr(),
                    output_surface_id));
   }
   DidReceiveFrameFromRenderer();
 }
 
 void RenderWidgetHostViewAura::SendDelegatedFrameAck(uint32 output_surface_id) {
   cc::CompositorFrameAck ack;
-  window_->layer()->TakeUnusedResourcesForChildCompositor(&ack.resources);
-  RenderWidgetHostImpl::SendSwapCompositorFrameAck(
-      host_->GetRoutingID(), output_surface_id,
-      host_->GetProcess()->GetID(), ack);
+  if (resource_collection_)
+    resource_collection_->TakeUnusedResourcesForChildCompositor(&ack.resources);
+  RenderWidgetHostImpl::SendSwapCompositorFrameAck(host_->GetRoutingID(),
+                                                   output_surface_id,
+                                                   host_->GetProcess()->GetID(),
+                                                   ack);
+}
+
+void RenderWidgetHostViewAura::UnusedResourcesAreAvailable() {
+  // TODO(danakj): If no ack is pending, collect and send resources now.
 }
 
 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 =
@@ skipping 1867 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content