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

cc/layers/delegated_frame_provider.cc

Index: cc/layers/delegated_frame_provider.cc
diff --git a/cc/layers/delegated_frame_provider.cc b/cc/layers/delegated_frame_provider.cc
new file mode 100644
index 0000000000000000000000000000000000000000..84a28e45f7c593cbc334601bd2a60d80edf9cdb0
--- /dev/null
+++ b/cc/layers/delegated_frame_provider.cc
@@ -0,0 +1,98 @@
+// Copyright 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 "cc/layers/delegated_frame_provider.h"
+
+#include "cc/layers/delegated_frame_resource_collection.h"
+#include "cc/layers/delegated_renderer_layer.h"
+#include "cc/output/delegated_frame_data.h"
+#include "cc/quads/render_pass_draw_quad.h"
+
+namespace cc {
+
+DelegatedFrameProvider::DelegatedFrameProvider(
+    DelegatedFrameResourceCollection* resource_collection,
+    scoped_ptr<DelegatedFrameData> frame)
+    : resource_collection_(resource_collection),
+      frame_observer_(NULL),
+      own_frame_resources_(false) {
+  RenderPass* root_pass = frame->render_pass_list.back();
+  frame_size_ = root_pass->output_rect.size();
+  DCHECK(!frame_size_.IsEmpty());
+  SetFrameData(frame.Pass());
+}
+
+DelegatedFrameProvider::~DelegatedFrameProvider() {}
+
+void DelegatedFrameProvider::SetObserver(DelegatedRendererLayer* observer) {
+  if (frame_observer_ == observer)
+    return;
+
+  frame_observer_ = observer;
+  // A new observer will have to use full frame damage the first time anyway, so
+  // clear the damage rect.
+  damage_ = gfx::RectF();
+
+  if (frame_observer_) {
+    DCHECK(frame_)
+        << "Must have a frame when given to a DelegatedRendererLayer.";
+    frame_observer_->ProviderHasNewFrame();
+  }
+}
+
+bool DelegatedFrameProvider::IsObserver(
+    DelegatedRendererLayer* observer) const {
+  return frame_observer_ == observer;
+}
+
+void DelegatedFrameProvider::SetFrameData(
+    scoped_ptr<DelegatedFrameData> frame) {
+  DCHECK(frame);
+  DCHECK_NE(0u, frame->render_pass_list.size());
+
+  if (own_frame_resources_) {
+    ReturnedResourceArray unused;
+    TransferableResource::ReturnResources(frame_->resource_list, &unused);
+    resource_collection_->ReturnResources(unused);
+  }
+
+  frame_ = frame.Pass();
+
+  RenderPass* root_pass = frame_->render_pass_list.back();
+  DCHECK_EQ(frame_size_.ToString(), root_pass->output_rect.size().ToString())
+      << "All frames in a single DelegatedFrameProvider must have the same "
+      << "size. Use a new frame provider for frames of a different size.";
+
+  damage_ = gfx::UnionRects(damage_, root_pass->damage_rect);
+  own_frame_resources_ = true;
+
+  if (frame_observer_)
+    frame_observer_->ProviderHasNewFrame();
+}
+
+DelegatedFrameData* DelegatedFrameProvider::GetFrameDataAndRefResources(
+    DelegatedRendererLayer* observer,
+    gfx::RectF* damage) {
+  DCHECK(frame_observer_ == observer);
+
+  *damage = damage_;
+  // Drop the damage since this frame will be drawn. The observer is now
+  // responsible for the damage.
+  damage_ = gfx::RectF();
+
+  if (own_frame_resources_) {
+    resource_collection_->ReceivedResources(frame_->resource_list);
+    own_frame_resources_ = false;
+  }
+
+  resource_collection_->RefResources(frame_->resource_list);
+  return frame_.get();
+}
+
+ReturnCallback
+DelegatedFrameProvider::GetReturnResourcesCallbackForImplThread() {
+  return resource_collection_->GetReturnResourcesCallbackForImplThread();
+}
+
+}  // namespace cc