cc: Chromify Layer and LayerImpl classes.

android_webview/browser/browser_view_renderer_impl.cc

 // Copyright (c) 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 "android_webview/browser/browser_view_renderer_impl.h"
 
 #include <android/bitmap.h>
 
 #include "android_webview/common/renderer_picture_map.h"
 #include "android_webview/public/browser/draw_gl.h"
@@ skipping 115 matching lines @@
   return UserData::GetInstance(contents);
 }
 
 BrowserViewRendererImpl::BrowserViewRendererImpl(
     BrowserViewRenderer::Client* client,
     JavaHelper* java_helper)
     : client_(client),
       java_helper_(java_helper),
       view_renderer_host_(new ViewRendererHost(NULL, this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(compositor_(Compositor::Create(this))),
-      view_clip_layer_(cc::Layer::create()),
-      transform_layer_(cc::Layer::create()),
-      scissor_clip_layer_(cc::Layer::create()),
+      view_clip_layer_(cc::Layer::Create()),
+      transform_layer_(cc::Layer::Create()),
+      scissor_clip_layer_(cc::Layer::Create()),
       view_visible_(false),
       compositor_visible_(false),
       is_composite_pending_(false),
       dpi_scale_(1.0f),
       page_scale_(1.0f),
       on_new_picture_mode_(kOnNewPictureDisabled),
       last_frame_context_(NULL),
       web_contents_(NULL),
       update_frame_info_callback_(
           base::Bind(&BrowserViewRendererImpl::OnFrameInfoUpdated,
                      base::Unretained(ALLOW_THIS_IN_INITIALIZER_LIST(this)))) {
 
   DCHECK(java_helper);
 
   // Define the view hierarchy.
-  transform_layer_->addChild(view_clip_layer_);
-  scissor_clip_layer_->addChild(transform_layer_);
+  transform_layer_->AddChild(view_clip_layer_);
+  scissor_clip_layer_->AddChild(transform_layer_);
   compositor_->SetRootLayer(scissor_clip_layer_);
 
   RendererPictureMap::CreateInstance();
 }
 
 BrowserViewRendererImpl::~BrowserViewRendererImpl() {
   SetContents(NULL);
 }
 
 // static
@@ skipping 22 matching lines @@
   if (!content_view_core)
     return;
 
   web_contents_ = content_view_core->GetWebContents();
   web_contents_->SetUserData(kUserDataKey, new UserData(this));
   view_renderer_host_->Observe(web_contents_);
 
   content_view_core->AddFrameInfoCallback(update_frame_info_callback_);
   dpi_scale_ = content_view_core->GetDpiScale();
 
-  view_clip_layer_->removeAllChildren();
-  view_clip_layer_->addChild(content_view_core->GetLayer());
+  view_clip_layer_->RemoveAllChildren();
+  view_clip_layer_->AddChild(content_view_core->GetLayer());
   Invalidate();
 }
 
 void BrowserViewRendererImpl::WebContentsGone() {
   web_contents_ = NULL;
 }
 
 void BrowserViewRendererImpl::DrawGL(AwDrawGLInfo* draw_info) {
   TRACE_EVENT0("android_webview", "BrowserViewRendererImpl::DrawGL");
 
@@ skipping 21 matching lines @@
     last_frame_context_ = current_context;
   }
 
   compositor_->SetWindowBounds(gfx::Size(draw_info->width, draw_info->height));
 
   if (draw_info->is_layer) {
     // When rendering into a separate layer no view clipping, transform,
     // scissoring or background transparency need to be handled.
     // The Android framework will composite us afterwards.
     compositor_->SetHasTransparentBackground(false);
-    view_clip_layer_->setMasksToBounds(false);
-    transform_layer_->setTransform(gfx::Transform());
-    scissor_clip_layer_->setMasksToBounds(false);
-    scissor_clip_layer_->setPosition(gfx::PointF());
-    scissor_clip_layer_->setBounds(gfx::Size());
-    scissor_clip_layer_->setSublayerTransform(gfx::Transform());
+    view_clip_layer_->SetMasksToBounds(false);
+    transform_layer_->SetTransform(gfx::Transform());
+    scissor_clip_layer_->SetMasksToBounds(false);
+    scissor_clip_layer_->SetPosition(gfx::PointF());
+    scissor_clip_layer_->SetBounds(gfx::Size());
+    scissor_clip_layer_->SetSublayerTransform(gfx::Transform());
 
   } else {
     compositor_->SetHasTransparentBackground(true);
 
     gfx::Rect clip_rect(draw_info->clip_left, draw_info->clip_top,
                         draw_info->clip_right - draw_info->clip_left,
                         draw_info->clip_bottom - draw_info->clip_top);
 
-    scissor_clip_layer_->setPosition(clip_rect.origin());
-    scissor_clip_layer_->setBounds(clip_rect.size());
-    scissor_clip_layer_->setMasksToBounds(true);
+    scissor_clip_layer_->SetPosition(clip_rect.origin());
+    scissor_clip_layer_->SetBounds(clip_rect.size());
+    scissor_clip_layer_->SetMasksToBounds(true);
 
     // The compositor clipping architecture enforces us to have the clip layer
     // as an ancestor of the area we want to clip, but this makes the transform
     // become relative to the clip area rather than the full surface. The clip
     // position offset needs to be undone before applying the transform.
     gfx::Transform undo_clip_position;
     undo_clip_position.Translate(-clip_rect.x(), -clip_rect.y());
-    scissor_clip_layer_->setSublayerTransform(undo_clip_position);
+    scissor_clip_layer_->SetSublayerTransform(undo_clip_position);
 
     gfx::Transform transform;
     transform.matrix().setColMajorf(draw_info->transform);
 
     // The scrolling values of the Android Framework affect the transformation
     // matrix. This needs to be undone to let the compositor handle scrolling.
     // TODO(leandrogracia): when scrolling becomes synchronous we should undo
     // or override the translation in the compositor, not the one coming from
     // the Android View System, as it could be out of bounds for overscrolling.
     transform.Translate(hw_rendering_scroll_.x(), hw_rendering_scroll_.y());
-    transform_layer_->setTransform(transform);
+    transform_layer_->SetTransform(transform);
 
-    view_clip_layer_->setMasksToBounds(true);
+    view_clip_layer_->SetMasksToBounds(true);
   }
 
   compositor_->Composite();
   is_composite_pending_ = false;
 
   // The GL functor must ensure these are set to zero before returning.
   // Not setting them leads to graphical artifacts that can affect other apps.
   glBindBuffer(GL_ARRAY_BUFFER, 0);
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 }
@@ skipping 109 matching lines @@
 }
 
 void BrowserViewRendererImpl::OnVisibilityChanged(bool view_visible,
                                                   bool window_visible) {
   view_visible_ = window_visible && view_visible;
   Invalidate();
 }
 
 void BrowserViewRendererImpl::OnSizeChanged(int width, int height) {
   view_size_ = gfx::Size(width, height);
-  view_clip_layer_->setBounds(view_size_);
+  view_clip_layer_->SetBounds(view_size_);
 }
 
 void BrowserViewRendererImpl::OnAttachedToWindow(int width, int height) {
   view_size_ = gfx::Size(width, height);
-  view_clip_layer_->setBounds(view_size_);
+  view_clip_layer_->SetBounds(view_size_);
 }
 
 void BrowserViewRendererImpl::OnDetachedFromWindow() {
   view_visible_ = false;
   SetCompositorVisibility(false);
 }
 
 void BrowserViewRendererImpl::ScheduleComposite() {
   TRACE_EVENT0("android_webview", "BrowserViewRendererImpl::ScheduleComposite");
 
@@ skipping 88 matching lines @@
 
 void BrowserViewRendererImpl::OnFrameInfoUpdated(
     const gfx::SizeF& content_size,
     const gfx::Vector2dF& scroll_offset,
     float page_scale_factor) {
   page_scale_ = page_scale_factor;
   content_size_css_ = content_size;
 }
 
 }  // namespace android_webview