cc: Chromify Layer and LayerImpl classes.

cc/tiled_layer_impl.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/tiled_layer_impl.h"
 
 #include "base/basictypes.h"
 #include "base/stringprintf.h"
 #include "cc/append_quads_data.h"
 #include "cc/checkerboard_draw_quad.h"
 #include "cc/debug_border_draw_quad.h"
 #include "cc/debug_colors.h"
 #include "cc/layer_tiling_data.h"
 #include "cc/math_util.h"
 #include "cc/quad_sink.h"
 #include "cc/solid_color_draw_quad.h"
 #include "cc/tile_draw_quad.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/quad_f.h"
 
 namespace cc {
 
 // Temporary diagnostic.
 static bool safeToDeleteDrawableTile = false;
 
 class DrawableTile : public LayerTilingData::Tile {
 public:
-    static scoped_ptr<DrawableTile> create() { return make_scoped_ptr(new DrawableTile()); }
+    static scoped_ptr<DrawableTile> Create() { return make_scoped_ptr(new DrawableTile()); }
 
     virtual ~DrawableTile() { CHECK(safeToDeleteDrawableTile); }
 
     ResourceProvider::ResourceId resourceId() const { return m_resourceId; }
     void setResourceId(ResourceProvider::ResourceId resourceId) { m_resourceId = resourceId; }
     bool contentsSwizzled() { return m_contentsSwizzled; }
     void setContentsSwizzled(bool contentsSwizzled) { m_contentsSwizzled = contentsSwizzled; }
 
 private:
     DrawableTile()
@@ skipping 13 matching lines @@
 }
 
 TiledLayerImpl::~TiledLayerImpl()
 {
     safeToDeleteDrawableTile = true;
     if (m_tiler)
       m_tiler->reset();
     safeToDeleteDrawableTile = false;
 }
 
-ResourceProvider::ResourceId TiledLayerImpl::contentsResourceId() const
+ResourceProvider::ResourceId TiledLayerImpl::ContentsResourceId() const
 {
     // This function is only valid for single texture layers, e.g. masks.
     DCHECK(m_tiler);
     DCHECK(m_tiler->numTilesX() == 1);
     DCHECK(m_tiler->numTilesY() == 1);
 
     DrawableTile* tile = tileAt(0, 0);
     ResourceProvider::ResourceId resourceId = tile ? tile->resourceId() : 0;
     return resourceId;
 }
 
-void TiledLayerImpl::dumpLayerProperties(std::string* str, int indent) const
+void TiledLayerImpl::DumpLayerProperties(std::string* str, int indent) const
 {
-    str->append(indentString(indent));
+    str->append(IndentString(indent));
     base::StringAppendF(str, "skipsDraw: %d\n", (!m_tiler || m_skipsDraw));
-    LayerImpl::dumpLayerProperties(str, indent);
+    LayerImpl::DumpLayerProperties(str, indent);
 }
 
 bool TiledLayerImpl::hasTileAt(int i, int j) const
 {
     return m_tiler->tileAt(i, j);
 }
 
 bool TiledLayerImpl::hasResourceIdForTileAt(int i, int j) const
 {
     return hasTileAt(i, j) && tileAt(i, j)->resourceId();
 }
 
 DrawableTile* TiledLayerImpl::tileAt(int i, int j) const
 {
     return static_cast<DrawableTile*>(m_tiler->tileAt(i, j));
 }
 
 DrawableTile* TiledLayerImpl::createTile(int i, int j)
 {
-    scoped_ptr<DrawableTile> tile(DrawableTile::create());
+    scoped_ptr<DrawableTile> tile(DrawableTile::Create());
     DrawableTile* addedTile = tile.get();
     m_tiler->addTile(tile.PassAs<LayerTilingData::Tile>(), i, j);
 
     // Temporary diagnostic checks.
     CHECK(addedTile);
     CHECK(tileAt(i, j));
 
     return addedTile;
 }
 
-void TiledLayerImpl::getDebugBorderProperties(SkColor* color, float* width) const
+void TiledLayerImpl::GetDebugBorderProperties(SkColor* color, float* width) const
 {
     *color = DebugColors::TiledContentLayerBorderColor();
-    *width = DebugColors::TiledContentLayerBorderWidth(layerTreeImpl());
+    *width = DebugColors::TiledContentLayerBorderWidth(layer_tree_impl());
 }
 
-scoped_ptr<LayerImpl> TiledLayerImpl::createLayerImpl(LayerTreeImpl* treeImpl)
+scoped_ptr<LayerImpl> TiledLayerImpl::CreateLayerImpl(LayerTreeImpl* treeImpl)
 {
-    return TiledLayerImpl::create(treeImpl, id()).PassAs<LayerImpl>();
+    return TiledLayerImpl::Create(treeImpl, id()).PassAs<LayerImpl>();
 }
 
-void TiledLayerImpl::pushPropertiesTo(LayerImpl* layer)
+void TiledLayerImpl::PushPropertiesTo(LayerImpl* layer)
 {
-    LayerImpl::pushPropertiesTo(layer);
+    LayerImpl::PushPropertiesTo(layer);
 
     TiledLayerImpl* tiledLayer = static_cast<TiledLayerImpl*>(layer);
 
     tiledLayer->setSkipsDraw(m_skipsDraw);
     tiledLayer->setTilingData(*m_tiler);
 
     for (LayerTilingData::TileMap::const_iterator iter = m_tiler->tiles().begin(); iter != m_tiler->tiles().end(); ++iter) {
         int i = iter->first.first;
         int j = iter->first.second;
         DrawableTile* tile = static_cast<DrawableTile*>(iter->second);
 
         tiledLayer->pushTileProperties(i, j, tile->resourceId(), tile->opaqueRect(), tile->contentsSwizzled());
     }
 }
 
-void TiledLayerImpl::appendQuads(QuadSink& quadSink, AppendQuadsData& appendQuadsData)
+void TiledLayerImpl::AppendQuads(QuadSink* quadSink, AppendQuadsData* appendQuadsData)
 {
-    const gfx::Rect& contentRect = visibleContentRect();
+    const gfx::Rect& contentRect = visible_content_rect();
 
     if (!m_tiler || m_tiler->hasEmptyBounds() || contentRect.IsEmpty())
         return;
 
-    SharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
-    appendDebugBorderQuad(quadSink, sharedQuadState, appendQuadsData);
+    SharedQuadState* sharedQuadState = quadSink->useSharedQuadState(CreateSharedQuadState());
+    AppendDebugBorderQuad(quadSink, sharedQuadState, appendQuadsData);
 
     int left, top, right, bottom;
     m_tiler->contentRectToTileIndices(contentRect, left, top, right, bottom);
 
-    if (showDebugBorders()) {
+    if (ShowDebugBorders()) {
         for (int j = top; j <= bottom; ++j) {
             for (int i = left; i <= right; ++i) {
                 DrawableTile* tile = tileAt(i, j);
                 gfx::Rect tileRect = m_tiler->tileBounds(i, j);
                 SkColor borderColor;
                 float borderWidth;
 
                 if (m_skipsDraw || !tile || !tile->resourceId()) {
                     borderColor = DebugColors::MissingTileBorderColor();
-                    borderWidth = DebugColors::MissingTileBorderWidth(layerTreeImpl());
+                    borderWidth = DebugColors::MissingTileBorderWidth(layer_tree_impl());
                 } else {
                     borderColor = DebugColors::HighResTileBorderColor();
-                    borderWidth = DebugColors::HighResTileBorderWidth(layerTreeImpl());
+                    borderWidth = DebugColors::HighResTileBorderWidth(layer_tree_impl());
                 }
                 scoped_ptr<DebugBorderDrawQuad> debugBorderQuad = DebugBorderDrawQuad::Create();
                 debugBorderQuad->SetNew(sharedQuadState, tileRect, borderColor, borderWidth);
-                quadSink.append(debugBorderQuad.PassAs<DrawQuad>(), appendQuadsData);
+                quadSink->append(debugBorderQuad.PassAs<DrawQuad>(), appendQuadsData);
             }
         }
     }
 
     if (m_skipsDraw)
         return;
 
     for (int j = top; j <= bottom; ++j) {
         for (int i = left; i <= right; ++i) {
             DrawableTile* tile = tileAt(i, j);
             gfx::Rect tileRect = m_tiler->tileBounds(i, j);
             gfx::Rect displayRect = tileRect;
             tileRect.Intersect(contentRect);
 
             // Skip empty tiles.
             if (tileRect.IsEmpty())
                 continue;
 
             if (!tile || !tile->resourceId()) {
-                if (drawCheckerboardForMissingTiles()) {
+                if (DrawCheckerboardForMissingTiles()) {
                     SkColor checkerColor;
-                    if (showDebugBorders())
+                    if (ShowDebugBorders())
                         checkerColor = tile ? DebugColors::InvalidatedTileCheckerboardColor() : DebugColors::EvictedTileCheckerboardColor();
                     else
                         checkerColor = DebugColors::DefaultCheckerboardColor();
 
                     scoped_ptr<CheckerboardDrawQuad> checkerboardQuad = CheckerboardDrawQuad::Create();
                     checkerboardQuad->SetNew(sharedQuadState, tileRect, checkerColor);
-                    if (quadSink.append(checkerboardQuad.PassAs<DrawQuad>(), appendQuadsData))
-                        appendQuadsData.numMissingTiles++;
+                    if (quadSink->append(checkerboardQuad.PassAs<DrawQuad>(), appendQuadsData))
+                        appendQuadsData->numMissingTiles++;
                 } else {
                     scoped_ptr<SolidColorDrawQuad> solidColorQuad = SolidColorDrawQuad::Create();
-                    solidColorQuad->SetNew(sharedQuadState, tileRect, backgroundColor());
-                    if (quadSink.append(solidColorQuad.PassAs<DrawQuad>(), appendQuadsData))
-                        appendQuadsData.numMissingTiles++;
+                    solidColorQuad->SetNew(sharedQuadState, tileRect, background_color());
+                    if (quadSink->append(solidColorQuad.PassAs<DrawQuad>(), appendQuadsData))
+                        appendQuadsData->numMissingTiles++;
                 }
                 continue;
             }
 
-            gfx::Rect tileOpaqueRect = contentsOpaque() ? tileRect : gfx::IntersectRects(tile->opaqueRect(), contentRect);
+            gfx::Rect tileOpaqueRect = contents_opaque() ? tileRect : gfx::IntersectRects(tile->opaqueRect(), contentRect);
 
             // Keep track of how the top left has moved, so the texture can be
             // offset the same amount.
             gfx::Vector2d displayOffset = tileRect.origin() - displayRect.origin();
             gfx::Vector2d textureOffset = m_tiler->textureOffset(i, j) + displayOffset;
             gfx::RectF texCoordRect = gfx::RectF(tileRect.size()) + textureOffset;
 
             float tileWidth = static_cast<float>(m_tiler->tileSize().width());
             float tileHeight = static_cast<float>(m_tiler->tileSize().height());
             gfx::Size textureSize(tileWidth, tileHeight);
 
             scoped_ptr<TileDrawQuad> quad = TileDrawQuad::Create();
             quad->SetNew(sharedQuadState, tileRect, tileOpaqueRect, tile->resourceId(), texCoordRect, textureSize, tile->contentsSwizzled());
-            quadSink.append(quad.PassAs<DrawQuad>(), appendQuadsData);
+            quadSink->append(quad.PassAs<DrawQuad>(), appendQuadsData);
         }
     }
 }
 
 void TiledLayerImpl::setTilingData(const LayerTilingData& tiler)
 {
     safeToDeleteDrawableTile = true;
 
     if (m_tiler)
         m_tiler->reset();
@@ skipping 17 matching lines @@
 void TiledLayerImpl::pushInvalidTile(int i, int j)
 {
     DrawableTile* tile = tileAt(i, j);
     if (!tile)
         tile = createTile(i, j);
     tile->setResourceId(0);
     tile->setOpaqueRect(gfx::Rect());
     tile->setContentsSwizzled(false);
 }
 
-Region TiledLayerImpl::visibleContentOpaqueRegion() const
+Region TiledLayerImpl::VisibleContentOpaqueRegion() const
 {
     if (m_skipsDraw)
         return Region();
-    if (contentsOpaque())
-        return visibleContentRect();
-    return m_tiler->opaqueRegionInContentRect(visibleContentRect());
+    if (contents_opaque())
+        return visible_content_rect();
+    return m_tiler->opaqueRegionInContentRect(visible_content_rect());
 }
 
-void TiledLayerImpl::didLoseOutputSurface()
+void TiledLayerImpl::DidLoseOutputSurface()
 {
     safeToDeleteDrawableTile = true;
     // Temporary diagnostic check.
     CHECK(m_tiler);
     m_tiler->reset();
     safeToDeleteDrawableTile = false;
 }
 
-const char* TiledLayerImpl::layerTypeAsString() const
+const char* TiledLayerImpl::LayerTypeAsString() const
 {
     return "ContentLayer";
 }
 
 }  // namespace cc