cc: Move WebCompositorOutputSurface and related classes into cc/

cc/software_renderer.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 "cc/software_renderer.h"
 
-#include <public/WebCompositorSoftwareOutputDevice.h>
 #include <public/WebImage.h>
-#include <public/WebSize.h>
 
 #include "base/debug/trace_event.h"
 #include "cc/debug_border_draw_quad.h"
 #include "cc/math_util.h"
 #include "cc/render_pass_draw_quad.h"
+#include "cc/software_output_device.h"
 #include "cc/solid_color_draw_quad.h"
 #include "cc/texture_draw_quad.h"
 #include "cc/tile_draw_quad.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkMatrix.h"
 #include "third_party/skia/include/core/SkShader.h"
 #include "third_party/skia/include/effects/SkLayerRasterizer.h"
 #include "ui/gfx/rect_conversions.h"
 #include "ui/gfx/skia_util.h"
 #include "ui/gfx/transform.h"
 
-using WebKit::WebCompositorSoftwareOutputDevice;
-using WebKit::WebSize;
-
 namespace cc {
 
 namespace {
 
 void toSkMatrix(SkMatrix* flattened, const gfx::Transform& m)
 {
     // Convert from 4x4 to 3x3 by dropping the third row and column.
     flattened->set(0, SkDoubleToScalar(m.matrix().getDouble(0, 0)));
     flattened->set(1, SkDoubleToScalar(m.matrix().getDouble(0, 1)));
     flattened->set(2, SkDoubleToScalar(m.matrix().getDouble(0, 3)));
     flattened->set(3, SkDoubleToScalar(m.matrix().getDouble(1, 0)));
     flattened->set(4, SkDoubleToScalar(m.matrix().getDouble(1, 1)));
     flattened->set(5, SkDoubleToScalar(m.matrix().getDouble(1, 3)));
     flattened->set(6, SkDoubleToScalar(m.matrix().getDouble(3, 0)));
     flattened->set(7, SkDoubleToScalar(m.matrix().getDouble(3, 1)));
     flattened->set(8, SkDoubleToScalar(m.matrix().getDouble(3, 3)));
 }
 
 bool isScaleAndTranslate(const SkMatrix& matrix)
 {
     return SkScalarNearlyZero(matrix[SkMatrix::kMSkewX]) &&
            SkScalarNearlyZero(matrix[SkMatrix::kMSkewY]) &&
            SkScalarNearlyZero(matrix[SkMatrix::kMPersp0]) &&
            SkScalarNearlyZero(matrix[SkMatrix::kMPersp1]) &&
            SkScalarNearlyZero(matrix[SkMatrix::kMPersp2] - 1.0f);
 }
 
 } // anonymous namespace
 
-scoped_ptr<SoftwareRenderer> SoftwareRenderer::create(RendererClient* client, ResourceProvider* resourceProvider, WebCompositorSoftwareOutputDevice* outputDevice)
+scoped_ptr<SoftwareRenderer> SoftwareRenderer::create(RendererClient* client, ResourceProvider* resourceProvider, SoftwareOutputDevice* outputDevice)
 {
     return make_scoped_ptr(new SoftwareRenderer(client, resourceProvider, outputDevice));
 }
 
-SoftwareRenderer::SoftwareRenderer(RendererClient* client, ResourceProvider* resourceProvider, WebCompositorSoftwareOutputDevice* outputDevice)
+SoftwareRenderer::SoftwareRenderer(RendererClient* client, ResourceProvider* resourceProvider, SoftwareOutputDevice* outputDevice)
     : DirectRenderer(client, resourceProvider)
     , m_visible(true)
     , m_outputDevice(outputDevice)
     , m_skCurrentCanvas(0)
 {
     m_resourceProvider->setDefaultResourceType(ResourceProvider::Bitmap);
 
     m_capabilities.maxTextureSize = INT_MAX;
     m_capabilities.bestTextureFormat = GL_RGBA;
     m_capabilities.contextHasCachedFrontBuffer = true;
     m_capabilities.usingSetVisibility = true;
 
     viewportChanged();
 }
 
 SoftwareRenderer::~SoftwareRenderer()
 {
 }
 
 const RendererCapabilities& SoftwareRenderer::capabilities() const
 {
     return m_capabilities;
 }
 
 void SoftwareRenderer::viewportChanged()
 {
-    m_outputDevice->didChangeViewportSize(WebSize(viewportSize().width(), viewportSize().height()));
+    m_outputDevice->DidChangeViewportSize(viewportSize());
 }
 
 void SoftwareRenderer::beginDrawingFrame(DrawingFrame& frame)
 {
     TRACE_EVENT0("cc", "SoftwareRenderer::beginDrawingFrame");
-    m_skRootCanvas = make_scoped_ptr(new SkCanvas(m_outputDevice->lock(true)->getSkBitmap()));
+    m_skRootCanvas = make_scoped_ptr(new SkCanvas(m_outputDevice->Lock(true)->getSkBitmap()));
 }
 
 void SoftwareRenderer::finishDrawingFrame(DrawingFrame& frame)
 {
     TRACE_EVENT0("cc", "SoftwareRenderer::finishDrawingFrame");
     m_currentFramebufferLock.reset();
     m_skCurrentCanvas = 0;
     m_skRootCanvas.reset();
-    m_outputDevice->unlock();
+    m_outputDevice->Unlock();
 }
 
 bool SoftwareRenderer::flippedFramebuffer() const
 {
     return false;
 }
 
 void SoftwareRenderer::ensureScissorTestEnabled()
 {
     // Nothing to do here. Current implementation of software rendering has no
@@ skipping 245 matching lines @@
 bool SoftwareRenderer::swapBuffers()
 {
     if (m_client->hasImplThread())
         m_client->onSwapBuffersComplete();
     return true;
 }
 
 void SoftwareRenderer::getFramebufferPixels(void *pixels, const gfx::Rect& rect)
 {
     TRACE_EVENT0("cc", "SoftwareRenderer::getFramebufferPixels");
-    SkBitmap fullBitmap = m_outputDevice->lock(false)->getSkBitmap();
+    SkBitmap fullBitmap = m_outputDevice->Lock(false)->getSkBitmap();
     SkBitmap subsetBitmap;
     SkIRect invertRect = SkIRect::MakeXYWH(rect.x(), viewportSize().height() - rect.bottom(), rect.width(), rect.height());
     fullBitmap.extractSubset(&subsetBitmap, invertRect);
     subsetBitmap.copyPixelsTo(pixels, rect.width() * rect.height() * 4, rect.width() * 4);
-    m_outputDevice->unlock();
+    m_outputDevice->Unlock();
 }
 
 void SoftwareRenderer::setVisible(bool visible)
 {
     if (m_visible == visible)
         return;
     m_visible = visible;
 }
 
 }  // namespace cc