delegated_renderer_layer.cc revision 7dbb3d5cf0c15f500944d211057644d6a2f37371 
1// Copyright 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "cc/layers/delegated_renderer_layer.h"
6
7#include "cc/layers/delegated_renderer_layer_client.h"
8#include "cc/layers/delegated_renderer_layer_impl.h"
9#include "cc/output/delegated_frame_data.h"
10
11namespace cc {
12
13scoped_refptr<DelegatedRendererLayer> DelegatedRendererLayer::Create(
14    DelegatedRendererLayerClient* client) {
15  return scoped_refptr<DelegatedRendererLayer>(
16      new DelegatedRendererLayer(client));
17}
18
19DelegatedRendererLayer::DelegatedRendererLayer(
20    DelegatedRendererLayerClient* client)
21    : Layer(),
22    client_(client) {}
23
24DelegatedRendererLayer::~DelegatedRendererLayer() {}
25
26scoped_ptr<LayerImpl> DelegatedRendererLayer::CreateLayerImpl(
27    LayerTreeImpl* tree_impl) {
28  return DelegatedRendererLayerImpl::Create(
29      tree_impl, layer_id_).PassAs<LayerImpl>();
30}
31
32bool DelegatedRendererLayer::DrawsContent() const {
33  return Layer::DrawsContent() && !frame_size_.IsEmpty();
34}
35
36void DelegatedRendererLayer::PushPropertiesTo(LayerImpl* impl) {
37  Layer::PushPropertiesTo(impl);
38
39  DelegatedRendererLayerImpl* delegated_impl =
40      static_cast<DelegatedRendererLayerImpl*>(impl);
41
42  delegated_impl->SetDisplaySize(display_size_);
43
44  if (!frame_data_) {
45    delegated_impl->SetFrameData(scoped_ptr<DelegatedFrameData>(),
46                                 gfx::Rect(),
47                                 &unused_resources_for_child_compositor_);
48  } else if (frame_size_.IsEmpty()) {
49    scoped_ptr<DelegatedFrameData> empty_frame(new DelegatedFrameData);
50    delegated_impl->SetFrameData(empty_frame.Pass(),
51                                 gfx::Rect(),
52                                 &unused_resources_for_child_compositor_);
53  } else {
54    delegated_impl->SetFrameData(frame_data_.Pass(),
55                                 damage_in_frame_,
56                                 &unused_resources_for_child_compositor_);
57  }
58  frame_data_.reset();
59  damage_in_frame_ = gfx::RectF();
60
61  if (client_)
62    client_->DidCommitFrameData();
63
64  // TODO(danakj): TakeUnusedResourcesForChildCompositor requires a push
65  // properties to happen in order to push up newly unused resources returned
66  // from the parent compositor. crbug.com/259090
67  needs_push_properties_ = true;
68}
69
70void DelegatedRendererLayer::SetDisplaySize(gfx::Size size) {
71  if (display_size_ == size)
72    return;
73  display_size_ = size;
74  SetNeedsCommit();
75}
76
77void DelegatedRendererLayer::SetFrameData(
78    scoped_ptr<DelegatedFrameData> new_frame_data) {
79  if (frame_data_) {
80    // Copy the resources from the last provided frame into the new frame, as
81    // it may use resources that were transferred in the last frame.
82    new_frame_data->resource_list.insert(new_frame_data->resource_list.end(),
83                                         frame_data_->resource_list.begin(),
84                                         frame_data_->resource_list.end());
85  }
86  frame_data_ = new_frame_data.Pass();
87  if (!frame_data_->render_pass_list.empty()) {
88    RenderPass* root_pass = frame_data_->render_pass_list.back();
89    damage_in_frame_.Union(root_pass->damage_rect);
90    frame_size_ = root_pass->output_rect.size();
91
92    // TODO(danakj): This could be optimized to only add resources to the
93    // frame_data_ if they are actually used in the frame. For now, it will
94    // cause the parent (this layer) to hold onto some resources it doesn't
95    // need to for an extra frame.
96    for (size_t i = 0; i < unused_resources_for_child_compositor_.size(); ++i) {
97      frame_data_->resource_list.push_back(
98          unused_resources_for_child_compositor_[i]);
99    }
100    unused_resources_for_child_compositor_.clear();
101  } else {
102    frame_size_ = gfx::Size();
103  }
104  SetNeedsCommit();
105}
106
107void DelegatedRendererLayer::TakeUnusedResourcesForChildCompositor(
108    TransferableResourceArray* array) {
109  DCHECK(array->empty());
110  array->clear();
111
112  array->swap(unused_resources_for_child_compositor_);
113}
114
115bool DelegatedRendererLayer::BlocksPendingCommit() const {
116  // The active frame needs to be replaced and resources returned before the
117  // commit is called complete. This is true even whenever there may be
118  // resources to return, regardless of if the layer will draw in its new
119  // state.
120  return true;
121}
122
123}  // namespace cc
124