cc: Chromify Layer and LayerImpl classes.

cc/nine_patch_layer_impl.cc

 // Copyright 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 "nine_patch_layer_impl.h"
 
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "cc/quad_sink.h"
 #include "cc/texture_draw_quad.h"
 #include "ui/gfx/rect_f.h"
 
 namespace cc {
 
 NinePatchLayerImpl::NinePatchLayerImpl(LayerTreeImpl* tree_impl, int id)
     : LayerImpl(tree_impl, id),
       resource_id_(0) {}
 
 NinePatchLayerImpl::~NinePatchLayerImpl() {}
 
-ResourceProvider::ResourceId NinePatchLayerImpl::contentsResourceId() const {
+ResourceProvider::ResourceId NinePatchLayerImpl::ContentsResourceId() const {
   return 0;
 }
 
-scoped_ptr<LayerImpl> NinePatchLayerImpl::createLayerImpl(
+scoped_ptr<LayerImpl> NinePatchLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
   return NinePatchLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
-void NinePatchLayerImpl::pushPropertiesTo(LayerImpl* layer) {
-  LayerImpl::pushPropertiesTo(layer);
+void NinePatchLayerImpl::PushPropertiesTo(LayerImpl* layer) {
+  LayerImpl::PushPropertiesTo(layer);
   NinePatchLayerImpl* layer_impl = static_cast<NinePatchLayerImpl*>(layer);
 
   if (!resource_id_)
     return;
 
   layer_impl->SetResourceId(resource_id_);
   layer_impl->SetLayout(image_bounds_, image_aperture_);
 }
 
-void NinePatchLayerImpl::willDraw(ResourceProvider* resource_provider) {}
+void NinePatchLayerImpl::WillDraw(ResourceProvider* resource_provider) {}
 
 static gfx::RectF NormalizedRect(float x,
                                  float y,
                                  float width,
                                  float height,
                                  float total_width,
                                  float total_height) {
   return gfx::RectF(x / total_width,
                     y / total_height,
                     width / total_width,
                     height / total_height);
 }
 
 void NinePatchLayerImpl::SetLayout(gfx::Size image_bounds, gfx::Rect aperture) {
   image_bounds_ = image_bounds;
   image_aperture_ = aperture;
 }
 
-void NinePatchLayerImpl::appendQuads(QuadSink& quad_sink,
-                                     AppendQuadsData& append_quads_data) {
+void NinePatchLayerImpl::AppendQuads(QuadSink* quad_sink,
+                                     AppendQuadsData* append_quads_data) {
   if (!resource_id_)
     return;
 
   SharedQuadState* shared_quad_state =
-      quad_sink.useSharedQuadState(createSharedQuadState());
-  appendDebugBorderQuad(quad_sink, shared_quad_state, append_quads_data);
+      quad_sink->useSharedQuadState(CreateSharedQuadState());
+  AppendDebugBorderQuad(quad_sink, shared_quad_state, append_quads_data);
 
   static const bool flipped = false;
   static const bool premultiplied_alpha = true;
 
   DCHECK(!bounds().IsEmpty());
 
   // NinePatch border widths in bitmap pixel space
   int left_width = image_aperture_.x();
   int top_height = image_aperture_.y();
   int right_width = image_bounds_.width() - image_aperture_.right();
@@ skipping 88 matching lines @@
 
   quad = TextureDrawQuad::Create();
   quad->SetNew(shared_quad_state,
                top_left,
                opaque_rect,
                resource_id_,
                premultiplied_alpha,
                uv_top_left.origin(),
                uv_top_left.bottom_right(),
                vertex_opacity, flipped);
-  quad_sink.append(quad.PassAs<DrawQuad>(), append_quads_data);
+  quad_sink->append(quad.PassAs<DrawQuad>(), append_quads_data);
 
   quad = TextureDrawQuad::Create();
   quad->SetNew(shared_quad_state,
                topRight,
                opaque_rect,
                resource_id_,
                premultiplied_alpha,
                uv_top_right.origin(),
                uv_top_right.bottom_right(),
                vertex_opacity, flipped);
-  quad_sink.append(quad.PassAs<DrawQuad>(), append_quads_data);
+  quad_sink->append(quad.PassAs<DrawQuad>(), append_quads_data);
 
   quad = TextureDrawQuad::Create();
   quad->SetNew(shared_quad_state,
                bottomLeft,
                opaque_rect,
                resource_id_,
                premultiplied_alpha,
                uv_bottom_left.origin(),
                uv_bottom_left.bottom_right(),
                vertex_opacity,
                flipped);
-  quad_sink.append(quad.PassAs<DrawQuad>(), append_quads_data);
+  quad_sink->append(quad.PassAs<DrawQuad>(), append_quads_data);
 
   quad = TextureDrawQuad::Create();
   quad->SetNew(shared_quad_state,
                bottomRight,
                opaque_rect,
                resource_id_,
                premultiplied_alpha,
                uv_bottom_right.origin(),
                uv_bottom_right.bottom_right(),
                vertex_opacity,
                flipped);
-  quad_sink.append(quad.PassAs<DrawQuad>(), append_quads_data);
+  quad_sink->append(quad.PassAs<DrawQuad>(), append_quads_data);
 
   quad = TextureDrawQuad::Create();
   quad->SetNew(shared_quad_state,
                top,
                opaque_rect,
                resource_id_,
                premultiplied_alpha,
                uvTop.origin(),
                uvTop.bottom_right(),
                vertex_opacity,
                flipped);
-  quad_sink.append(quad.PassAs<DrawQuad>(), append_quads_data);
+  quad_sink->append(quad.PassAs<DrawQuad>(), append_quads_data);
 
   quad = TextureDrawQuad::Create();
   quad->SetNew(shared_quad_state,
                left,
                opaque_rect,
                resource_id_,
                premultiplied_alpha,
                uvLeft.origin(),
                uvLeft.bottom_right(),
                vertex_opacity,
                flipped);
-  quad_sink.append(quad.PassAs<DrawQuad>(), append_quads_data);
+  quad_sink->append(quad.PassAs<DrawQuad>(), append_quads_data);
 
   quad = TextureDrawQuad::Create();
   quad->SetNew(shared_quad_state,
                right,
                opaque_rect,
                resource_id_,
                premultiplied_alpha,
                uvRight.origin(),
                uvRight.bottom_right(),
                vertex_opacity,
                flipped);
-  quad_sink.append(quad.PassAs<DrawQuad>(), append_quads_data);
+  quad_sink->append(quad.PassAs<DrawQuad>(), append_quads_data);
 
   quad = TextureDrawQuad::Create();
   quad->SetNew(shared_quad_state,
                bottom,
                opaque_rect,
                resource_id_,
                premultiplied_alpha,
                uvBottom.origin(),
                uvBottom.bottom_right(),
                vertex_opacity,
                flipped);
-  quad_sink.append(quad.PassAs<DrawQuad>(), append_quads_data);
+  quad_sink->append(quad.PassAs<DrawQuad>(), append_quads_data);
 }
 
-void NinePatchLayerImpl::didDraw(ResourceProvider* resource_provider) {}
+void NinePatchLayerImpl::DidDraw(ResourceProvider* resource_provider) {}
 
-void NinePatchLayerImpl::didLoseOutputSurface() {
+void NinePatchLayerImpl::DidLoseOutputSurface() {
   resource_id_ = 0;
 }
 
-const char* NinePatchLayerImpl::layerTypeAsString() const {
+const char* NinePatchLayerImpl::LayerTypeAsString() const {
   return "NinePatchLayer";
 }
 
-void NinePatchLayerImpl::dumpLayerProperties(std::string* str, int indent)
+void NinePatchLayerImpl::DumpLayerProperties(std::string* str, int indent)
     const {
-  str->append(indentString(indent));
+  str->append(IndentString(indent));
   base::StringAppendF(
       str, "imageAperture: %s\n", image_aperture_.ToString().c_str());
   base::StringAppendF(
       str, "image_bounds: %s\n", image_bounds_.ToString().c_str());
-  LayerImpl::dumpLayerProperties(str, indent);
+  LayerImpl::DumpLayerProperties(str, indent);
 }
 
-base::DictionaryValue* NinePatchLayerImpl::layerTreeAsJson() const {
-  base::DictionaryValue* result = LayerImpl::layerTreeAsJson();
+base::DictionaryValue* NinePatchLayerImpl::LayerTreeAsJson() const {
+  base::DictionaryValue* result = LayerImpl::LayerTreeAsJson();
 
   base::ListValue* list = new base::ListValue;
   list->AppendInteger(image_aperture_.origin().x());
   list->AppendInteger(image_aperture_.origin().y());
   list->AppendInteger(image_aperture_.size().width());
   list->AppendInteger(image_aperture_.size().height());
   result->Set("ImageAperture", list);
 
   list = new base::ListValue;
   list->AppendInteger(image_bounds_.width());
   list->AppendInteger(image_bounds_.height());
   result->Set("ImageBounds", list);
 
   return result;
 }
 
 }  // namespace cc