cc: Remove LayerImpl::SetContentBounds()

cc/trees/layer_tree_host_impl_unittest.cc

 // Copyright 2011 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/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/bind.h"
@@ skipping 169 matching lines @@
     host_impl_->SetViewportSize(gfx::Size(10, 10));
     // Set the BeginFrameArgs so that methods which use it are able to.
     host_impl_->WillBeginImplFrame(
         CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
     return init;
   }
 
   void SetupRootLayerImpl(scoped_ptr<LayerImpl> root) {
     root->SetPosition(gfx::PointF());
     root->SetBounds(gfx::Size(10, 10));
-    root->SetContentBounds(gfx::Size(10, 10));
     root->SetDrawsContent(true);
     root->draw_properties().visible_content_rect = gfx::Rect(0, 0, 10, 10);
     root->SetHasRenderSurface(true);
     host_impl_->active_tree()->SetRootLayer(root.Pass());
   }
 
   static void ExpectClearedScrollDeltasRecursive(LayerImpl* layer) {
     ASSERT_EQ(layer->ScrollDelta(), gfx::Vector2d());
     for (size_t i = 0; i < layer->children().size(); ++i)
       ExpectClearedScrollDeltasRecursive(layer->children()[i]);
@@ skipping 34 matching lines @@
     const int kOuterViewportClipLayerId = 116;
     const int kOuterViewportScrollLayerId = 117;
     const int kContentLayerId = 118;
     const int kInnerViewportScrollLayerId = 2;
     const int kInnerViewportClipLayerId = 4;
     const int kPageScaleLayerId = 5;
 
     scoped_ptr<LayerImpl> root =
         LayerImpl::Create(layer_tree_impl, 1);
     root->SetBounds(content_size);
-    root->SetContentBounds(content_size);
     root->SetPosition(gfx::PointF());
     root->SetHasRenderSurface(true);
 
     scoped_ptr<LayerImpl> inner_scroll =
         LayerImpl::Create(layer_tree_impl, kInnerViewportScrollLayerId);
     inner_scroll->SetIsContainerForFixedPositionLayers(true);
     inner_scroll->PushScrollOffsetFromMainThread(gfx::ScrollOffset());
 
     scoped_ptr<LayerImpl> inner_clip =
         LayerImpl::Create(layer_tree_impl, kInnerViewportClipLayerId);
     inner_clip->SetBounds(
         gfx::Size(content_size.width() / 2, content_size.height() / 2));
 
     scoped_ptr<LayerImpl> page_scale =
         LayerImpl::Create(layer_tree_impl, kPageScaleLayerId);
 
     inner_scroll->SetScrollClipLayer(inner_clip->id());
     inner_scroll->SetBounds(content_size);
-    inner_scroll->SetContentBounds(content_size);
     inner_scroll->SetPosition(gfx::PointF());
 
     scoped_ptr<LayerImpl> outer_clip =
         LayerImpl::Create(layer_tree_impl, kOuterViewportClipLayerId);
     outer_clip->SetBounds(content_size);
     outer_clip->SetIsContainerForFixedPositionLayers(true);
 
     scoped_ptr<LayerImpl> outer_scroll =
         LayerImpl::Create(layer_tree_impl, kOuterViewportScrollLayerId);
     outer_scroll->SetScrollClipLayer(outer_clip->id());
     outer_scroll->PushScrollOffsetFromMainThread(gfx::ScrollOffset());
     outer_scroll->SetBounds(content_size);
-    outer_scroll->SetContentBounds(content_size);
     outer_scroll->SetPosition(gfx::PointF());
 
     scoped_ptr<LayerImpl> contents =
         LayerImpl::Create(layer_tree_impl, kContentLayerId);
     contents->SetDrawsContent(true);
     contents->SetBounds(content_size);
-    contents->SetContentBounds(content_size);
     contents->SetPosition(gfx::PointF());
 
     outer_scroll->AddChild(contents.Pass());
     outer_clip->AddChild(outer_scroll.Pass());
     inner_scroll->AddChild(outer_clip.Pass());
     page_scale->AddChild(inner_scroll.Pass());
     inner_clip->AddChild(page_scale.Pass());
     root->AddChild(inner_clip.Pass());
 
     layer_tree_impl->SetRootLayer(root.Pass());
@@ skipping 16 matching lines @@
   scoped_ptr<LayerImpl> CreateScrollableLayer(int id,
                                               const gfx::Size& size,
                                               LayerImpl* clip_layer) {
     DCHECK(clip_layer);
     DCHECK(id != clip_layer->id());
     scoped_ptr<LayerImpl> layer =
         LayerImpl::Create(host_impl_->active_tree(), id);
     layer->SetScrollClipLayer(clip_layer->id());
     layer->SetDrawsContent(true);
     layer->SetBounds(size);
-    layer->SetContentBounds(size);
     clip_layer->SetBounds(gfx::Size(size.width() / 2, size.height() / 2));
     return layer.Pass();
   }
 
   void DrawFrame() {
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
     host_impl_->DrawLayers(&frame);
     host_impl_->DidDrawAllLayers(frame);
   }
@@ skipping 307 matching lines @@
   LayerImpl* root = host_impl_->active_tree()->root_layer();
 
   LayerImpl* child = 0;
   {
     scoped_ptr<LayerImpl> child_layer =
         LayerImpl::Create(host_impl_->active_tree(), 6);
     child = child_layer.get();
     child_layer->SetDrawsContent(true);
     child_layer->SetPosition(gfx::PointF(0, 20));
     child_layer->SetBounds(gfx::Size(50, 50));
-    child_layer->SetContentBounds(gfx::Size(50, 50));
     scroll->AddChild(child_layer.Pass());
   }
 
   // Touch handler regions determine whether touch events block scroll.
   root->SetTouchEventHandlerRegion(gfx::Rect(0, 0, 100, 100));
   EXPECT_FALSE(host_impl_->DoTouchEventsBlockScrollAt(gfx::Point(10, 10)));
   root->SetScrollBlocksOn(SCROLL_BLOCKS_ON_START_TOUCH |
                           SCROLL_BLOCKS_ON_WHEEL_EVENT);
   EXPECT_TRUE(host_impl_->DoTouchEventsBlockScrollAt(gfx::Point(10, 10)));
 
@@ skipping 353 matching lines @@
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollWithUserUnscrollableLayers) {
   LayerImpl* scroll_layer = SetupScrollAndContentsLayers(gfx::Size(200, 200));
   host_impl_->SetViewportSize(gfx::Size(100, 100));
 
   gfx::Size overflow_size(400, 400);
   ASSERT_EQ(1u, scroll_layer->children().size());
   LayerImpl* overflow = scroll_layer->children()[0];
   overflow->SetBounds(overflow_size);
-  overflow->SetContentBounds(overflow_size);
   overflow->SetScrollClipLayer(scroll_layer->parent()->id());
   overflow->PushScrollOffsetFromMainThread(gfx::ScrollOffset());
   overflow->SetPosition(gfx::PointF());
 
   DrawFrame();
   gfx::Point scroll_position(10, 10);
 
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(scroll_position, InputHandler::WHEEL));
   EXPECT_VECTOR_EQ(gfx::Vector2dF(), scroll_layer->CurrentScrollOffset());
@@ skipping 107 matching lines @@
       SetupScrollAndContentsLayers(gfx::Size(100, 100));
 
   // Adjust the content layer to be larger than the outer viewport container so
   // that we get scrolling in both viewports.
   LayerImpl* content_layer =
       host_impl_->OuterViewportScrollLayer()->children().back();
   LayerImpl* outer_scroll_layer = host_impl_->OuterViewportScrollLayer();
   LayerImpl* inner_clip_layer =
       host_impl_->InnerViewportScrollLayer()->parent()->parent();
   inner_clip_layer->SetBounds(gfx::Size(100, 100));
-  inner_clip_layer->SetContentBounds(gfx::Size(100, 100));
   outer_scroll_layer->SetBounds(gfx::Size(200, 200));
-  outer_scroll_layer->SetContentBounds(gfx::Size(200, 200));
   content_layer->SetBounds(gfx::Size(200, 200));
-  content_layer->SetContentBounds(gfx::Size(200, 200));
 
   host_impl_->SetViewportSize(gfx::Size(100, 100));
 
   EXPECT_VECTOR_EQ(
       gfx::Vector2dF(100, 100),
       outer_scroll_layer->MaxScrollOffset());
 
   host_impl_->ScrollBegin(gfx::Point(99, 99), InputHandler::GESTURE);
   host_impl_->PinchGestureBegin();
   host_impl_->PinchGestureUpdate(2, gfx::Point(99, 99));
@@ skipping 14 matching lines @@
       SetupScrollAndContentsLayers(gfx::Size(100, 100));
 
   // Adjust the content layer to be larger than the outer viewport container so
   // that we get scrolling in both viewports.
   LayerImpl* content_layer =
       host_impl_->OuterViewportScrollLayer()->children().back();
   LayerImpl* outer_scroll_layer = host_impl_->OuterViewportScrollLayer();
   LayerImpl* inner_clip_layer =
       host_impl_->InnerViewportScrollLayer()->parent()->parent();
   inner_clip_layer->SetBounds(gfx::Size(100, 100));
-  inner_clip_layer->SetContentBounds(gfx::Size(100, 100));
   outer_scroll_layer->SetBounds(gfx::Size(200, 200));
-  outer_scroll_layer->SetContentBounds(gfx::Size(200, 200));
   content_layer->SetBounds(gfx::Size(200, 200));
-  content_layer->SetContentBounds(gfx::Size(200, 200));
 
   host_impl_->SetViewportSize(gfx::Size(100, 100));
 
   DrawFrame();
 
   // Zoom into the page by a 2X factor
   float min_page_scale = 1.f, max_page_scale = 4.f;
   float page_scale_factor = 2.f;
   host_impl_->active_tree()->PushPageScaleFromMainThread(
       page_scale_factor, min_page_scale, max_page_scale);
@@ skipping 595 matching lines @@
     scoped_ptr<LayerImpl> root =
         LayerImpl::Create(host_impl_->active_tree(), 1);
     root->SetBounds(viewport_size);
 
     scoped_ptr<LayerImpl> scroll =
         LayerImpl::Create(host_impl_->active_tree(), 2);
     scroll->SetScrollClipLayer(root->id());
     scroll->PushScrollOffsetFromMainThread(gfx::ScrollOffset());
     root->SetBounds(viewport_size);
     scroll->SetBounds(content_size);
-    scroll->SetContentBounds(content_size);
     scroll->SetIsContainerForFixedPositionLayers(true);
 
     scoped_ptr<LayerImpl> contents =
         LayerImpl::Create(host_impl_->active_tree(), 3);
     contents->SetDrawsContent(true);
     contents->SetBounds(content_size);
-    contents->SetContentBounds(content_size);
 
     scoped_ptr<SolidColorScrollbarLayerImpl> scrollbar =
         SolidColorScrollbarLayerImpl::Create(host_impl_->active_tree(), 4,
                                              VERTICAL, 10, 0, false, true);
     EXPECT_FLOAT_EQ(0.f, scrollbar->opacity());
 
     scroll->AddChild(contents.Pass());
     root->AddChild(scroll.Pass());
     root->SetHasRenderSurface(true);
     scrollbar->SetScrollLayerAndClipLayerByIds(2, 1);
@@ skipping 130 matching lines @@
   scoped_ptr<LayerImpl> root =
       LayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetBounds(viewport_size);
   root->SetHasRenderSurface(true);
 
   scoped_ptr<LayerImpl> scroll =
       LayerImpl::Create(host_impl_->active_tree(), 2);
   scroll->SetScrollClipLayer(root->id());
   scroll->PushScrollOffsetFromMainThread(gfx::ScrollOffset());
   scroll->SetBounds(content_size);
-  scroll->SetContentBounds(content_size);
   scroll->SetIsContainerForFixedPositionLayers(true);
 
   scoped_ptr<LayerImpl> contents =
       LayerImpl::Create(host_impl_->active_tree(), 3);
   contents->SetDrawsContent(true);
   contents->SetBounds(content_size);
-  contents->SetContentBounds(content_size);
 
   // The scrollbar is on the right side.
   scoped_ptr<PaintedScrollbarLayerImpl> scrollbar =
       PaintedScrollbarLayerImpl::Create(host_impl_->active_tree(), 5, VERTICAL);
   scrollbar->SetDrawsContent(true);
   scrollbar->SetBounds(gfx::Size(15, viewport_size.height()));
-  scrollbar->SetContentBounds(gfx::Size(15, viewport_size.height()));
   scrollbar->SetPosition(gfx::Point(285, 0));
 
   scroll->AddChild(contents.Pass());
   root->AddChild(scroll.Pass());
   scrollbar->SetScrollLayerAndClipLayerByIds(2, 1);
   root->AddChild(scrollbar.Pass());
 
   host_impl_->active_tree()->SetRootLayer(root.Pass());
   host_impl_->active_tree()->SetViewportLayersFromIds(Layer::INVALID_ID, 1, 2,
                                                       Layer::INVALID_ID);
@@ skipping 172 matching lines @@
   }
 
  protected:
   DidDrawCheckLayer(LayerTreeImpl* tree_impl, int id)
       : LayerImpl(tree_impl, id),
         will_draw_returns_false_(false),
         will_draw_called_(false),
         append_quads_called_(false),
         did_draw_called_(false) {
     SetBounds(gfx::Size(10, 10));
-    SetContentBounds(gfx::Size(10, 10));
     SetDrawsContent(true);
     draw_properties().visible_content_rect = gfx::Rect(0, 0, 10, 10);
   }
 
  private:
   bool will_draw_returns_false_;
   bool will_draw_called_;
   bool append_quads_called_;
   bool did_draw_called_;
 };
@@ skipping 48 matching lines @@
   DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(
       host_impl_->active_tree()->root_layer());
   root->SetMasksToBounds(true);
   root->SetHasRenderSurface(true);
   root->AddChild(DidDrawCheckLayer::Create(host_impl_->active_tree(), 2));
   DidDrawCheckLayer* layer =
       static_cast<DidDrawCheckLayer*>(root->children()[0]);
   // Ensure visible_content_rect for layer is empty.
   layer->SetPosition(gfx::PointF(100.f, 100.f));
   layer->SetBounds(gfx::Size(10, 10));
-  layer->SetContentBounds(gfx::Size(10, 10));
 
   LayerTreeHostImpl::FrameData frame;
 
   EXPECT_FALSE(layer->will_draw_called());
   EXPECT_FALSE(layer->did_draw_called());
 
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame);
   host_impl_->DidDrawAllLayers(frame);
 
@@ skipping 31 matching lines @@
   DidDrawCheckLayer* occluded_layer =
       static_cast<DidDrawCheckLayer*>(root->children()[0]);
 
   root->AddChild(DidDrawCheckLayer::Create(host_impl_->active_tree(), 3));
   root->SetHasRenderSurface(true);
   DidDrawCheckLayer* top_layer =
       static_cast<DidDrawCheckLayer*>(root->children()[1]);
   // This layer covers the occluded_layer above. Make this layer large so it can
   // occlude.
   top_layer->SetBounds(big_size);
-  top_layer->SetContentBounds(big_size);
   top_layer->SetContentsOpaque(true);
 
   LayerTreeHostImpl::FrameData frame;
 
   EXPECT_FALSE(occluded_layer->will_draw_called());
   EXPECT_FALSE(occluded_layer->did_draw_called());
   EXPECT_FALSE(top_layer->will_draw_called());
   EXPECT_FALSE(top_layer->did_draw_called());
 
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
@@ skipping 362 matching lines @@
   }
 
   void SetupTopControlsAndScrollLayer() {
     scoped_ptr<LayerImpl> root =
         LayerImpl::Create(host_impl_->active_tree(), 1);
     scoped_ptr<LayerImpl> root_clip =
         LayerImpl::Create(host_impl_->active_tree(), 2);
     root_clip->SetBounds(clip_size_);
     root->SetScrollClipLayer(root_clip->id());
     root->SetBounds(layer_size_);
-    root->SetContentBounds(layer_size_);
     root->SetPosition(gfx::PointF());
     root->SetDrawsContent(false);
     root->SetIsContainerForFixedPositionLayers(true);
     int inner_viewport_scroll_layer_id = root->id();
     int page_scale_layer_id = root_clip->id();
     root_clip->SetHasRenderSurface(true);
     root_clip->AddChild(root.Pass());
     root_clip->SetHasRenderSurface(true);
     host_impl_->active_tree()->SetRootLayer(root_clip.Pass());
     host_impl_->active_tree()->SetViewportLayersFromIds(
         Layer::INVALID_ID, page_scale_layer_id, inner_viewport_scroll_layer_id,
         Layer::INVALID_ID);
     // Set a viewport size that is large enough to contain both the top controls
     // and some content.
     host_impl_->SetViewportSize(viewport_size_);
     host_impl_->sync_tree()->set_top_controls_shrink_blink_size(true);
 
     host_impl_->DidChangeTopControlsPosition();
 
     host_impl_->CreatePendingTree();
     host_impl_->sync_tree()->set_top_controls_height(top_controls_height_);
     root =
         LayerImpl::Create(host_impl_->sync_tree(), 1);
     root_clip =
         LayerImpl::Create(host_impl_->sync_tree(), 2);
     root_clip->SetBounds(clip_size_);
     root->SetScrollClipLayer(root_clip->id());
     root->SetBounds(layer_size_);
-    root->SetContentBounds(layer_size_);
     root->SetPosition(gfx::PointF());
     root->SetDrawsContent(false);
     root->SetIsContainerForFixedPositionLayers(true);
     inner_viewport_scroll_layer_id = root->id();
     page_scale_layer_id = root_clip->id();
     root_clip->AddChild(root.Pass());
     host_impl_->sync_tree()->SetRootLayer(root_clip.Pass());
     host_impl_->sync_tree()->SetViewportLayersFromIds(
         Layer::INVALID_ID, page_scale_layer_id, inner_viewport_scroll_layer_id,
         Layer::INVALID_ID);
@@ skipping 21 matching lines @@
         LayerImpl::Create(host_impl_->active_tree(), 3);
 
     scoped_ptr<LayerImpl> outer_scroll =
         LayerImpl::Create(host_impl_->active_tree(), 4);
     scoped_ptr<LayerImpl> outer_clip =
         LayerImpl::Create(host_impl_->active_tree(), 5);
 
     root_clip->SetBounds(inner_viewport_size);
     root->SetScrollClipLayer(root_clip->id());
     root->SetBounds(outer_viewport_size);
-    root->SetContentBounds(outer_viewport_size);
     root->SetPosition(gfx::PointF());
     root->SetDrawsContent(false);
     root->SetIsContainerForFixedPositionLayers(true);
     root_clip->SetHasRenderSurface(true);
     outer_clip->SetBounds(outer_viewport_size);
     outer_scroll->SetScrollClipLayer(outer_clip->id());
     outer_scroll->SetBounds(scroll_layer_size);
-    outer_scroll->SetContentBounds(scroll_layer_size);
     outer_scroll->SetPosition(gfx::PointF());
     outer_scroll->SetDrawsContent(false);
     outer_scroll->SetIsContainerForFixedPositionLayers(true);
 
     int inner_viewport_scroll_layer_id = root->id();
     int outer_viewport_scroll_layer_id = outer_scroll->id();
     int page_scale_layer_id = page_scale->id();
 
     outer_clip->AddChild(outer_scroll.Pass());
     root->AddChild(outer_clip.Pass());
@@ skipping 184 matching lines @@
   int id = outer_viewport_scroll_layer->id();
 
   scoped_ptr<LayerImpl> child =
       LayerImpl::Create(host_impl_->active_tree(), id + 2);
   scoped_ptr<LayerImpl> child_clip =
       LayerImpl::Create(host_impl_->active_tree(), id + 3);
 
   child_clip->SetBounds(sub_content_layer_size);
   child->SetScrollClipLayer(child_clip->id());
   child->SetBounds(sub_content_size);
-  child->SetContentBounds(sub_content_size);
   child->SetPosition(gfx::PointF());
   child->SetDrawsContent(true);
   child->SetIsContainerForFixedPositionLayers(true);
 
   // scroll child to limit
   child->SetScrollDelta(gfx::Vector2dF(0, 100.f));
   child_clip->AddChild(child.Pass());
   outer_viewport_scroll_layer->AddChild(child_clip.Pass());
 
   // Scroll 25px to hide top controls
@@ skipping 335 matching lines @@
   // Test the configuration where a non-composited root layer is embedded in a
   // scrollable outer layer.
   gfx::Size surface_size(10, 10);
   gfx::Size contents_size(20, 20);
 
   scoped_ptr<LayerImpl> content_layer =
       LayerImpl::Create(host_impl_->active_tree(), 1);
   content_layer->SetDrawsContent(true);
   content_layer->SetPosition(gfx::PointF());
   content_layer->SetBounds(contents_size);
-  content_layer->SetContentBounds(contents_size);
   content_layer->SetContentsScale(2.f, 2.f);
 
   scoped_ptr<LayerImpl> scroll_clip_layer =
       LayerImpl::Create(host_impl_->active_tree(), 3);
   scroll_clip_layer->SetBounds(surface_size);
 
   scoped_ptr<LayerImpl> scroll_layer =
       LayerImpl::Create(host_impl_->active_tree(), 2);
   scroll_layer->SetScrollClipLayer(3);
   scroll_layer->SetBounds(contents_size);
-  scroll_layer->SetContentBounds(contents_size);
   scroll_layer->SetPosition(gfx::PointF());
   scroll_layer->AddChild(content_layer.Pass());
   scroll_clip_layer->AddChild(scroll_layer.Pass());
 
   scroll_clip_layer->SetHasRenderSurface(true);
   host_impl_->active_tree()->SetRootLayer(scroll_clip_layer.Pass());
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(5, 5), InputHandler::WHEEL));
   host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
   host_impl_->ScrollEnd();
   EXPECT_TRUE(did_request_redraw_);
   EXPECT_TRUE(did_request_commit_);
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollChildCallsCommitAndRedraw) {
   gfx::Size surface_size(10, 10);
   gfx::Size contents_size(20, 20);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetBounds(surface_size);
-  root->SetContentBounds(contents_size);
   root->AddChild(CreateScrollableLayer(2, contents_size, root.get()));
   root->SetHasRenderSurface(true);
   host_impl_->active_tree()->SetRootLayer(root.Pass());
   host_impl_->SetViewportSize(surface_size);
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_STARTED,
             host_impl_->ScrollBegin(gfx::Point(5, 5), InputHandler::WHEEL));
   host_impl_->ScrollBy(gfx::Point(), gfx::Vector2d(0, 10));
   host_impl_->ScrollEnd();
@@ skipping 235 matching lines @@
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollChildAndChangePageScaleOnMainThread) {
   gfx::Size surface_size(30, 30);
   scoped_ptr<LayerImpl> root = LayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetBounds(gfx::Size(5, 5));
   root->SetHasRenderSurface(true);
   scoped_ptr<LayerImpl> root_scrolling =
       LayerImpl::Create(host_impl_->active_tree(), 2);
   root_scrolling->SetBounds(surface_size);
-  root_scrolling->SetContentBounds(surface_size);
   root_scrolling->SetScrollClipLayer(root->id());
   root_scrolling->SetIsContainerForFixedPositionLayers(true);
   LayerImpl* root_scrolling_ptr = root_scrolling.get();
   root->AddChild(root_scrolling.Pass());
   int child_scroll_layer_id = 3;
   scoped_ptr<LayerImpl> child_scrolling = CreateScrollableLayer(
       child_scroll_layer_id, surface_size, root_scrolling_ptr);
   LayerImpl* child = child_scrolling.get();
   root_scrolling_ptr->AddChild(child_scrolling.Pass());
   host_impl_->active_tree()->SetRootLayer(root.Pass());
@@ skipping 1062 matching lines @@
         quads_appended_(false),
         quad_rect_(5, 5, 5, 5),
         quad_visible_rect_(5, 5, 5, 5),
         resource_id_(resource_provider->CreateResource(
             gfx::Size(1, 1),
             GL_CLAMP_TO_EDGE,
             ResourceProvider::TEXTURE_HINT_IMMUTABLE,
             RGBA_8888)) {
     resource_provider->AllocateForTesting(resource_id_);
     SetBounds(gfx::Size(10, 10));
-    SetContentBounds(gfx::Size(10, 10));
     SetDrawsContent(true);
   }
 
   bool blend_;
   bool has_render_surface_;
   bool quads_appended_;
   gfx::Rect quad_rect_;
   gfx::Rect opaque_content_rect_;
   gfx::Rect quad_visible_rect_;
   ResourceId resource_id_;
 };
 
 TEST_F(LayerTreeHostImplTest, BlendingOffWhenDrawingOpaqueLayers) {
   {
     scoped_ptr<LayerImpl> root =
         LayerImpl::Create(host_impl_->active_tree(), 1);
     root->SetBounds(gfx::Size(10, 10));
-    root->SetContentBounds(root->bounds());
     root->SetDrawsContent(false);
     root->SetHasRenderSurface(true);
     host_impl_->active_tree()->SetRootLayer(root.Pass());
   }
   LayerImpl* root = host_impl_->active_tree()->root_layer();
 
   root->AddChild(
       BlendStateCheckLayer::Create(host_impl_->active_tree(),
                                    2,
                                    host_impl_->resource_provider()));
@@ skipping 236 matching lines @@
         host_impl_->active_tree()->root_layer()->children()[0]);
     child_->SetExpectation(false, false);
     child_->SetContentsOpaque(true);
   }
 
   // Expect no gutter rects.
   void TestLayerCoversFullViewport() {
     gfx::Rect layer_rect(viewport_size_);
     child_->SetPosition(layer_rect.origin());
     child_->SetBounds(layer_rect.size());
-    child_->SetContentBounds(layer_rect.size());
     child_->SetQuadRect(gfx::Rect(layer_rect.size()));
     child_->SetQuadVisibleRect(gfx::Rect(layer_rect.size()));
 
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
     ASSERT_EQ(1u, frame.render_passes.size());
 
     EXPECT_EQ(0u, CountGutterQuads(frame.render_passes[0]->quad_list));
     EXPECT_EQ(1u, frame.render_passes[0]->quad_list.size());
     ValidateTextureDrawQuads(frame.render_passes[0]->quad_list);
 
     VerifyQuadsExactlyCoverViewport(frame.render_passes[0]->quad_list);
     host_impl_->DidDrawAllLayers(frame);
   }
 
   // Expect fullscreen gutter rect.
   void TestEmptyLayer() {
     gfx::Rect layer_rect(0, 0, 0, 0);
     child_->SetPosition(layer_rect.origin());
     child_->SetBounds(layer_rect.size());
-    child_->SetContentBounds(layer_rect.size());
     child_->SetQuadRect(gfx::Rect(layer_rect.size()));
     child_->SetQuadVisibleRect(gfx::Rect(layer_rect.size()));
 
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
     ASSERT_EQ(1u, frame.render_passes.size());
 
     EXPECT_EQ(1u, CountGutterQuads(frame.render_passes[0]->quad_list));
     EXPECT_EQ(1u, frame.render_passes[0]->quad_list.size());
     ValidateTextureDrawQuads(frame.render_passes[0]->quad_list);
 
     VerifyQuadsExactlyCoverViewport(frame.render_passes[0]->quad_list);
     host_impl_->DidDrawAllLayers(frame);
   }
 
   // Expect four surrounding gutter rects.
   void TestLayerInMiddleOfViewport() {
     gfx::Rect layer_rect(500, 500, 200, 200);
     child_->SetPosition(layer_rect.origin());
     child_->SetBounds(layer_rect.size());
-    child_->SetContentBounds(layer_rect.size());
     child_->SetQuadRect(gfx::Rect(layer_rect.size()));
     child_->SetQuadVisibleRect(gfx::Rect(layer_rect.size()));
 
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
     ASSERT_EQ(1u, frame.render_passes.size());
 
     EXPECT_EQ(4u, CountGutterQuads(frame.render_passes[0]->quad_list));
     EXPECT_EQ(5u, frame.render_passes[0]->quad_list.size());
     ValidateTextureDrawQuads(frame.render_passes[0]->quad_list);
 
     VerifyQuadsExactlyCoverViewport(frame.render_passes[0]->quad_list);
     host_impl_->DidDrawAllLayers(frame);
   }
 
   // Expect no gutter rects.
   void TestLayerIsLargerThanViewport() {
     gfx::Rect layer_rect(viewport_size_.width() + 10,
                          viewport_size_.height() + 10);
     child_->SetPosition(layer_rect.origin());
     child_->SetBounds(layer_rect.size());
-    child_->SetContentBounds(layer_rect.size());
     child_->SetQuadRect(gfx::Rect(layer_rect.size()));
     child_->SetQuadVisibleRect(gfx::Rect(layer_rect.size()));
 
     LayerTreeHostImpl::FrameData frame;
     EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
     ASSERT_EQ(1u, frame.render_passes.size());
 
     EXPECT_EQ(0u, CountGutterQuads(frame.render_passes[0]->quad_list));
     EXPECT_EQ(1u, frame.render_passes[0]->quad_list.size());
     ValidateTextureDrawQuads(frame.render_passes[0]->quad_list);
@@ skipping 145 matching lines @@
 // viewport size is never set.
 TEST_F(LayerTreeHostImplTest, ReshapeNotCalledUntilDraw) {
   scoped_refptr<TestContextProvider> provider(TestContextProvider::Create());
   scoped_ptr<OutputSurface> output_surface(
       FakeOutputSurface::Create3d(provider));
   CreateHostImpl(DefaultSettings(), output_surface.Pass());
 
   scoped_ptr<LayerImpl> root =
       FakeDrawableLayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetBounds(gfx::Size(10, 10));
-  root->SetContentBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
   root->SetHasRenderSurface(true);
   host_impl_->active_tree()->SetRootLayer(root.Pass());
   EXPECT_FALSE(provider->TestContext3d()->reshape_called());
   provider->TestContext3d()->clear_reshape_called();
 
   LayerTreeHostImpl::FrameData frame;
   host_impl_->SetViewportSize(gfx::Size(10, 10));
   host_impl_->SetDeviceScaleFactor(1.f);
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
@@ skipping 51 matching lines @@
       CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE));
   layer_tree_host_impl->SetViewportSize(gfx::Size(500, 500));
 
   scoped_ptr<LayerImpl> root =
       FakeDrawableLayerImpl::Create(layer_tree_host_impl->active_tree(), 1);
   root->SetHasRenderSurface(true);
   scoped_ptr<LayerImpl> child =
       FakeDrawableLayerImpl::Create(layer_tree_host_impl->active_tree(), 2);
   child->SetPosition(gfx::PointF(12.f, 13.f));
   child->SetBounds(gfx::Size(14, 15));
-  child->SetContentBounds(gfx::Size(14, 15));
   child->SetDrawsContent(true);
   root->SetBounds(gfx::Size(500, 500));
-  root->SetContentBounds(gfx::Size(500, 500));
   root->SetDrawsContent(true);
   root->AddChild(child.Pass());
   layer_tree_host_impl->active_tree()->SetRootLayer(root.Pass());
 
   LayerTreeHostImpl::FrameData frame;
 
   // First frame, the entire screen should get swapped.
   EXPECT_EQ(DRAW_SUCCESS, layer_tree_host_impl->PrepareToDraw(&frame));
   layer_tree_host_impl->DrawLayers(&frame);
   layer_tree_host_impl->DidDrawAllLayers(frame);
@@ skipping 33 matching lines @@
   EXPECT_EQ(expected_swap_rect.ToString(),
             fake_output_surface->last_swap_rect().ToString());
 }
 
 TEST_F(LayerTreeHostImplTest, RootLayerDoesntCreateExtraSurface) {
   scoped_ptr<LayerImpl> root =
       FakeDrawableLayerImpl::Create(host_impl_->active_tree(), 1);
   scoped_ptr<LayerImpl> child =
       FakeDrawableLayerImpl::Create(host_impl_->active_tree(), 2);
   child->SetBounds(gfx::Size(10, 10));
-  child->SetContentBounds(gfx::Size(10, 10));
   child->SetDrawsContent(true);
   root->SetBounds(gfx::Size(10, 10));
-  root->SetContentBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
   root->SetHasRenderSurface(true);
   root->AddChild(child.Pass());
 
   host_impl_->active_tree()->SetRootLayer(root.Pass());
 
   LayerTreeHostImpl::FrameData frame;
 
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   EXPECT_EQ(1u, frame.render_surface_layer_list->size());
@@ skipping 236 matching lines @@
   scoped_ptr<LayerImpl> grand_child =
       FakeLayerWithQuads::Create(my_host_impl->active_tree(), 3);
 
   gfx::Rect root_rect(0, 0, 100, 100);
   gfx::Rect child_rect(10, 10, 50, 50);
   gfx::Rect grand_child_rect(5, 5, 150, 150);
 
   root->SetHasRenderSurface(true);
   root->SetPosition(root_rect.origin());
   root->SetBounds(root_rect.size());
-  root->SetContentBounds(root->bounds());
   root->draw_properties().visible_content_rect = root_rect;
   root->SetDrawsContent(false);
   root->render_surface()->SetContentRect(gfx::Rect(root_rect.size()));
 
   child->SetPosition(gfx::PointF(child_rect.x(), child_rect.y()));
   child->SetOpacity(0.5f);
   child->SetBounds(gfx::Size(child_rect.width(), child_rect.height()));
-  child->SetContentBounds(child->bounds());
   child->draw_properties().visible_content_rect = child_rect;
   child->SetDrawsContent(false);
   child->SetHasRenderSurface(true);
 
   grand_child->SetPosition(grand_child_rect.origin());
   grand_child->SetBounds(grand_child_rect.size());
-  grand_child->SetContentBounds(grand_child->bounds());
   grand_child->draw_properties().visible_content_rect = grand_child_rect;
   grand_child->SetDrawsContent(true);
 
   child->AddChild(grand_child.Pass());
   root->AddChild(child.Pass());
 
   my_host_impl->active_tree()->SetRootLayer(root.Pass());
   return my_host_impl.Pass();
 }
 
@@ skipping 59 matching lines @@
   root_layer->SetHasRenderSurface(true);
 
   scoped_refptr<VideoFrame> softwareFrame =
       media::VideoFrame::CreateColorFrame(
           gfx::Size(4, 4), 0x80, 0x80, 0x80, base::TimeDelta());
   FakeVideoFrameProvider provider;
   provider.set_frame(softwareFrame);
   scoped_ptr<VideoLayerImpl> video_layer = VideoLayerImpl::Create(
       host_impl_->active_tree(), 4, &provider, media::VIDEO_ROTATION_0);
   video_layer->SetBounds(gfx::Size(10, 10));
-  video_layer->SetContentBounds(gfx::Size(10, 10));
   video_layer->SetDrawsContent(true);
   root_layer->AddChild(video_layer.Pass());
 
   scoped_ptr<IOSurfaceLayerImpl> io_surface_layer =
       IOSurfaceLayerImpl::Create(host_impl_->active_tree(), 5);
   io_surface_layer->SetBounds(gfx::Size(10, 10));
-  io_surface_layer->SetContentBounds(gfx::Size(10, 10));
   io_surface_layer->SetDrawsContent(true);
   io_surface_layer->SetIOSurfaceProperties(1, gfx::Size(10, 10));
   root_layer->AddChild(io_surface_layer.Pass());
 
   host_impl_->active_tree()->SetRootLayer(root_layer.Pass());
 
   EXPECT_EQ(0u, context3d->NumTextures());
 
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
@@ skipping 135 matching lines @@
     host_impl_->DidDrawAllLayers(frame);
     EXPECT_EQ(expect_to_draw, host_impl_->SwapBuffers(frame));
   }
 };
 
 TEST_F(LayerTreeHostImplTestWithDelegatingRenderer, FrameIncludesDamageRect) {
   scoped_ptr<SolidColorLayerImpl> root =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetPosition(gfx::PointF());
   root->SetBounds(gfx::Size(10, 10));
-  root->SetContentBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
   root->SetHasRenderSurface(true);
 
   // Child layer is in the bottom right corner.
   scoped_ptr<SolidColorLayerImpl> child =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), 2);
   child->SetPosition(gfx::PointF(9.f, 9.f));
   child->SetBounds(gfx::Size(1, 1));
-  child->SetContentBounds(gfx::Size(1, 1));
   child->SetDrawsContent(true);
   root->AddChild(child.Pass());
 
   host_impl_->active_tree()->SetRootLayer(root.Pass());
 
   // Draw a frame. In the first frame, the entire viewport should be damaged.
   gfx::Rect full_frame_damage(host_impl_->DrawViewportSize());
   DrawFrameAndTestDamage(full_frame_damage);
 
   // The second frame has damage that doesn't touch the child layer. Its quads
@@ skipping 203 matching lines @@
 
   // SolidColorLayerImpl will be drawn.
   scoped_ptr<SolidColorLayerImpl> root_layer =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), 1);
 
   // VideoLayerImpl will not be drawn.
   FakeVideoFrameProvider provider;
   scoped_ptr<VideoLayerImpl> video_layer = VideoLayerImpl::Create(
       host_impl_->active_tree(), 2, &provider, media::VIDEO_ROTATION_0);
   video_layer->SetBounds(gfx::Size(10, 10));
-  video_layer->SetContentBounds(gfx::Size(10, 10));
   video_layer->SetDrawsContent(true);
   root_layer->AddChild(video_layer.Pass());
   SetupRootLayerImpl(root_layer.Pass());
 
   LayerTreeHostImpl::FrameData frame;
   EXPECT_EQ(DRAW_SUCCESS, host_impl_->PrepareToDraw(&frame));
   host_impl_->DrawLayers(&frame);
   host_impl_->DidDrawAllLayers(frame);
 
   EXPECT_EQ(1u, frame.will_draw_layers.size());
@@ skipping 404 matching lines @@
 
   int page_scale_layer_id = 5;
   LayerImpl* page_scale_layer =
       host_impl_->active_tree()->LayerById(page_scale_layer_id);
 
   int occluder_layer_id = 6;
   scoped_ptr<LayerImpl> occluder_layer =
       LayerImpl::Create(host_impl_->active_tree(), occluder_layer_id);
   occluder_layer->SetDrawsContent(true);
   occluder_layer->SetBounds(content_size);
-  occluder_layer->SetContentBounds(content_size);
   occluder_layer->SetPosition(gfx::PointF());
 
   // The parent of the occluder is *above* the scroller.
   page_scale_layer->AddChild(occluder_layer.Pass());
 
   DrawFrame();
 
   EXPECT_EQ(InputHandler::SCROLL_UNKNOWN,
             host_impl_->ScrollBegin(gfx::Point(), InputHandler::WHEEL));
 }
 
 TEST_F(LayerTreeHostImplTest, ScrollUnknownScrollAncestorMismatch) {
   // If we ray cast a scroller this is on the first layer's ancestor chain, but
   // is not the first scroller we encounter when walking up from the layer, we
   // should also return SCROLL_UNKNOWN.
   gfx::Size content_size(100, 100);
   SetupScrollAndContentsLayers(content_size);
 
   int scroll_layer_id = 2;
   LayerImpl* scroll_layer =
       host_impl_->active_tree()->LayerById(scroll_layer_id);
   scroll_layer->SetDrawsContent(true);
 
   int occluder_layer_id = 6;
   scoped_ptr<LayerImpl> occluder_layer =
       LayerImpl::Create(host_impl_->active_tree(), occluder_layer_id);
   occluder_layer->SetDrawsContent(true);
   occluder_layer->SetBounds(content_size);
-  occluder_layer->SetContentBounds(content_size);
   occluder_layer->SetPosition(gfx::PointF(-10.f, -10.f));
 
   int child_scroll_clip_layer_id = 7;
   scoped_ptr<LayerImpl> child_scroll_clip =
       LayerImpl::Create(host_impl_->active_tree(), child_scroll_clip_layer_id);
 
   int child_scroll_layer_id = 8;
   scoped_ptr<LayerImpl> child_scroll = CreateScrollableLayer(
       child_scroll_layer_id, content_size, child_scroll_clip.get());
 
@@ skipping 51 matching lines @@
   invisible_scroll_layer->SetDrawsContent(false);
 
   scoped_ptr<LayerImpl> child_layer =
       LayerImpl::Create(host_impl_->active_tree(), 8);
   child_layer->SetDrawsContent(false);
 
   scoped_ptr<LayerImpl> grand_child_layer =
       LayerImpl::Create(host_impl_->active_tree(), 9);
   grand_child_layer->SetDrawsContent(true);
   grand_child_layer->SetBounds(content_size);
-  grand_child_layer->SetContentBounds(content_size);
   // Move the grand child so it's not hit by our test point.
   grand_child_layer->SetPosition(gfx::PointF(10.f, 10.f));
 
   child_layer->AddChild(grand_child_layer.Pass());
   invisible_scroll_layer->AddChild(child_layer.Pass());
   root_scroll_layer->AddChild(invisible_scroll_layer.Pass());
 
   DrawFrame();
 
   // We should have scrolled |invisible_scroll_layer| as it was hit and it has
@@ skipping 16 matching lines @@
 
   int scroll_layer_id = 2;
   LayerImpl* scroll_layer =
       host_impl_->active_tree()->LayerById(scroll_layer_id);
 
   int scroll_child_id = 6;
   scoped_ptr<LayerImpl> scroll_child =
       LayerImpl::Create(host_impl_->active_tree(), scroll_child_id);
   scroll_child->SetDrawsContent(true);
   scroll_child->SetBounds(content_size);
-  scroll_child->SetContentBounds(content_size);
   // Move the scroll child so it's not hit by our test point.
   scroll_child->SetPosition(gfx::PointF(10.f, 10.f));
 
   int invisible_scroll_layer_id = 7;
   scoped_ptr<LayerImpl> invisible_scroll =
       CreateScrollableLayer(invisible_scroll_layer_id, content_size, root);
   invisible_scroll->SetDrawsContent(false);
 
   int container_id = 8;
   scoped_ptr<LayerImpl> container =
@@ skipping 21 matching lines @@
   EXPECT_EQ(7, host_impl_->CurrentlyScrollingLayer()->id());
 }
 
 // Make sure LatencyInfo carried by LatencyInfoSwapPromise are passed
 // to CompositorFrameMetadata after SwapBuffers();
 TEST_F(LayerTreeHostImplTest, LatencyInfoPassedToCompositorFrameMetadata) {
   scoped_ptr<SolidColorLayerImpl> root =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), 1);
   root->SetPosition(gfx::PointF());
   root->SetBounds(gfx::Size(10, 10));
-  root->SetContentBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
   root->SetHasRenderSurface(true);
 
   host_impl_->active_tree()->SetRootLayer(root.Pass());
 
   FakeOutputSurface* fake_output_surface =
       static_cast<FakeOutputSurface*>(host_impl_->output_surface());
 
   const std::vector<ui::LatencyInfo>& metadata_latency_before =
       fake_output_surface->last_sent_frame().metadata.latency_info;
@@ skipping 20 matching lines @@
   EXPECT_TRUE(metadata_latency_after[0].FindLatency(
       ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT, 0, NULL));
 }
 
 TEST_F(LayerTreeHostImplTest, SelectionBoundsPassedToCompositorFrameMetadata) {
   int root_layer_id = 1;
   scoped_ptr<SolidColorLayerImpl> root =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), root_layer_id);
   root->SetPosition(gfx::PointF());
   root->SetBounds(gfx::Size(10, 10));
-  root->SetContentBounds(gfx::Size(10, 10));
   root->SetDrawsContent(true);
   root->SetHasRenderSurface(true);
 
   host_impl_->active_tree()->SetRootLayer(root.Pass());
 
   // Ensure the default frame selection bounds are empty.
   FakeOutputSurface* fake_output_surface =
       static_cast<FakeOutputSurface*>(host_impl_->output_surface());
   const ViewportSelection& selection_before =
       fake_output_surface->last_sent_frame().metadata.selection;
@@ skipping 540 matching lines @@
 
     scoped_ptr<LayerImpl> inner_clip =
         LayerImpl::Create(layer_tree_impl, kInnerViewportClipLayerId);
     inner_clip->SetBounds(inner_viewport);
 
     scoped_ptr<LayerImpl> page_scale =
         LayerImpl::Create(layer_tree_impl, kPageScaleLayerId);
 
     inner_scroll->SetScrollClipLayer(inner_clip->id());
     inner_scroll->SetBounds(outer_viewport);
-    inner_scroll->SetContentBounds(outer_viewport);
     inner_scroll->SetPosition(gfx::PointF());
 
     scoped_ptr<LayerImpl> outer_clip =
         LayerImpl::Create(layer_tree_impl, kOuterViewportClipLayerId);
     outer_clip->SetBounds(outer_viewport);
     outer_clip->SetIsContainerForFixedPositionLayers(true);
 
     scoped_ptr<LayerImpl> outer_scroll =
         LayerImpl::Create(layer_tree_impl, kOuterViewportScrollLayerId);
     outer_scroll->SetScrollClipLayer(outer_clip->id());
     outer_scroll->PushScrollOffsetFromMainThread(gfx::ScrollOffset());
     outer_scroll->SetBounds(content_size);
-    outer_scroll->SetContentBounds(content_size);
     outer_scroll->SetPosition(gfx::PointF());
 
     scoped_ptr<LayerImpl> contents =
         LayerImpl::Create(layer_tree_impl, 8);
     contents->SetDrawsContent(true);
     contents->SetBounds(content_size);
-    contents->SetContentBounds(content_size);
     contents->SetPosition(gfx::PointF());
 
     outer_scroll->AddChild(contents.Pass());
     outer_clip->AddChild(outer_scroll.Pass());
     inner_scroll->AddChild(outer_clip.Pass());
     page_scale->AddChild(inner_scroll.Pass());
     inner_clip->AddChild(page_scale.Pass());
 
     inner_clip->SetHasRenderSurface(true);
     layer_tree_impl->SetRootLayer(inner_clip.Pass());
@@ skipping 721 matching lines @@
   // Hold an unowned pointer to the output surface to use for mock expectations.
   MockReclaimResourcesOutputSurface* mock_output_surface = output_surface.get();
 
   CreateHostImpl(DefaultSettings(), output_surface.Pass());
   EXPECT_CALL(*mock_output_surface, ForceReclaimResources()).Times(1);
   host_impl_->BeginCommit();
 }
 
 }  // namespace
 }  // namespace cc