Changed SoftwareOutputDevice interface.

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 "base/debug/trace_event.h"
+#include "cc/compositor_frame.h"
+#include "cc/compositor_frame_ack.h"
+#include "cc/compositor_frame_metadata.h"
 #include "cc/debug_border_draw_quad.h"
 #include "cc/math_util.h"
+#include "cc/output_surface.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/WebKit/Source/Platform/chromium/public/WebImage.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkDevice.h"
 #include "third_party/skia/include/core/SkMatrix.h"
@@ skipping 25 matching lines @@
 {
     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, SoftwareOutputDevice* outputDevice)
+scoped_ptr<SoftwareRenderer> SoftwareRenderer::create(RendererClient* client, OutputSurface* outputSurface, ResourceProvider* resourceProvider)
 {
-    return make_scoped_ptr(new SoftwareRenderer(client, resourceProvider, outputDevice));
+    return make_scoped_ptr(new SoftwareRenderer(client, outputSurface, resourceProvider));
 }
 
-SoftwareRenderer::SoftwareRenderer(RendererClient* client, ResourceProvider* resourceProvider, SoftwareOutputDevice* outputDevice)
+SoftwareRenderer::SoftwareRenderer(RendererClient* client,
+                                   OutputSurface* outputSurface,
+                                   ResourceProvider* resourceProvider)
     : DirectRenderer(client, resourceProvider)
+    , m_outputSurface(outputSurface)
     , m_visible(true)
     , m_isScissorEnabled(false)
-    , m_outputDevice(outputDevice)
+    , m_outputDevice(outputSurface->software_device())
     , m_skCurrentCanvas(0)
 {
     m_resourceProvider->setDefaultResourceType(ResourceProvider::Bitmap);
 
     m_capabilities.maxTextureSize = m_resourceProvider->maxTextureSize();
     m_capabilities.bestTextureFormat = m_resourceProvider->bestTextureFormat();
     m_capabilities.usingSetVisibility = true;
     // The updater can access bitmaps while the SoftwareRenderer is using them.
     m_capabilities.allowPartialTextureUpdates = true;
     m_capabilities.usingPartialSwap = true;
+    if (m_client->hasImplThread())
+      m_capabilities.usingSwapCompleteCallback = true;
+    m_compositorFrame.software_frame_data.reset(new SoftwareFrameData());
 
     viewportChanged();
 }
 
 SoftwareRenderer::~SoftwareRenderer()
 {
 }
 
 const RendererCapabilities& SoftwareRenderer::capabilities() const
 {
     return m_capabilities;
 }
 
 void SoftwareRenderer::viewportChanged()
 {
-    m_outputDevice->DidChangeViewportSize(viewportSize());
+    m_outputDevice->Resize(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 = m_outputDevice->BeginPaint(
+        gfx::ToEnclosingRect(frame.rootDamageRect));
 }
 
 void SoftwareRenderer::finishDrawingFrame(DrawingFrame& frame)
 {
     TRACE_EVENT0("cc", "SoftwareRenderer::finishDrawingFrame");
     m_currentFramebufferLock.reset();
-    m_skCurrentCanvas = 0;
-    m_skRootCanvas.reset();
-    m_outputDevice->Unlock();
+    m_skCurrentCanvas = NULL;
+    m_skRootCanvas = NULL;
+    if (settings().compositorFrameMessage) {
+        m_compositorFrame.metadata = m_client->makeCompositorFrameMetadata();
+        m_outputDevice->EndPaint(m_compositorFrame.software_frame_data.get());
+    } else {
+        m_outputDevice->EndPaint();
+    }
+}
+
+bool SoftwareRenderer::swapBuffers()
+{
+    if (settings().compositorFrameMessage)
+        m_outputSurface->SendFrameToParentCompositor(&m_compositorFrame);
+    return true;
+}
+
+void SoftwareRenderer::receiveCompositorFrameAck(const CompositorFrameAck& ack)
+{
+    if (m_client->hasImplThread())
+        m_client->onSwapBuffersComplete();
+    m_outputDevice->ReclaimDIB(ack.last_content_dib);

[enne (OOO), 2013/03/01 23:51:34]

It seems weird to land this function that calls ReclaimDIB which is NOTREACHED. 
I assume this is just a wart of landing a small part of a larger patch sequence,
but what's the larger context of this change?

 }
 
 bool SoftwareRenderer::flippedFramebuffer() const
 {
     return false;
 }
 
 void SoftwareRenderer::ensureScissorTestEnabled()
 {
     m_isScissorEnabled = true;
@@ skipping 11 matching lines @@
     setClipRect(gfx::Rect(device->width(), device->height()));
 }
 
 void SoftwareRenderer::finish()
 {
 }
 
 void SoftwareRenderer::bindFramebufferToOutputSurface(DrawingFrame& frame)
 {
     m_currentFramebufferLock.reset();
-    m_skCurrentCanvas = m_skRootCanvas.get();
+    m_skCurrentCanvas = m_skRootCanvas;
 }
 
 bool SoftwareRenderer::bindFramebufferToTexture(DrawingFrame& frame, const ScopedResource* texture, const gfx::Rect& framebufferRect)
 {
     m_currentFramebufferLock = make_scoped_ptr(new ResourceProvider::ScopedWriteLockSoftware(m_resourceProvider, texture->id()));
     m_skCurrentCanvas = m_currentFramebufferLock->skCanvas();
     initializeMatrices(frame, framebufferRect, false);
     setDrawViewportSize(framebufferRect.size());
 
     return true;
@@ skipping 219 matching lines @@
     }
 }
 
 void SoftwareRenderer::drawUnsupportedQuad(const DrawingFrame& frame, const DrawQuad* quad)
 {
     m_skCurrentPaint.setColor(SK_ColorMAGENTA);
     m_skCurrentPaint.setAlpha(quad->opacity() * 255);
     m_skCurrentCanvas->drawRect(gfx::RectFToSkRect(quadVertexRect()), m_skCurrentPaint);
 }
 
-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 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->CopyToBitmap(rect, &subsetBitmap);
+    subsetBitmap.copyPixelsTo(pixels,
+                              4 * rect.width() * rect.height(),
+                              4 * rect.width());
 }
 
 void SoftwareRenderer::setVisible(bool visible)
 {
     if (m_visible == visible)
         return;
     m_visible = visible;
 }
 
 }  // namespace cc