Unified OutputSurface::SwapBuffers.

cc/output/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/output/software_renderer.h"
 
 #include "base/debug/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_ack.h"
@@ skipping 38 matching lines @@
   return make_scoped_ptr(
       new SoftwareRenderer(client, output_surface, resource_provider));
 }
 
 SoftwareRenderer::SoftwareRenderer(RendererClient* client,
                                    OutputSurface* output_surface,
                                    ResourceProvider* resource_provider)
   : DirectRenderer(client, output_surface, resource_provider),
     visible_(true),
     is_scissor_enabled_(false),
-    is_viewport_changed_(true),
     output_device_(output_surface->software_device()),
     current_canvas_(NULL) {
   if (resource_provider_) {
     capabilities_.max_texture_size = resource_provider_->max_texture_size();
     capabilities_.best_texture_format =
         resource_provider_->best_texture_format();
   }
   capabilities_.using_set_visibility = true;
   // The updater can access bitmaps while the SoftwareRenderer is using them.
   capabilities_.allow_partial_texture_updates = true;
   capabilities_.using_partial_swap = true;
-  if (Settings().compositor_frame_message && client_->HasImplThread())
-    capabilities_.using_swap_complete_callback = true;
-  compositor_frame_.software_frame_data.reset(new SoftwareFrameData());
 }
 
 SoftwareRenderer::~SoftwareRenderer() {}
 
 const RendererCapabilities& SoftwareRenderer::Capabilities() const {
   return capabilities_;
 }
 
-void SoftwareRenderer::ViewportChanged() {
-  is_viewport_changed_ = true;
-}
-
 void SoftwareRenderer::BeginDrawingFrame(DrawingFrame* frame) {
   TRACE_EVENT0("cc", "SoftwareRenderer::BeginDrawingFrame");
-  if (is_viewport_changed_) {
-    is_viewport_changed_ = false;
-    output_device_->Resize(client_->DeviceViewport().size());
-  }
   root_canvas_ = output_device_->BeginPaint(
       gfx::ToEnclosingRect(frame->root_damage_rect));
 }
 
 void SoftwareRenderer::FinishDrawingFrame(DrawingFrame* frame) {
   TRACE_EVENT0("cc", "SoftwareRenderer::FinishDrawingFrame");
   current_framebuffer_lock_.reset();
   current_canvas_ = NULL;
   root_canvas_ = NULL;
-  if (Settings().compositor_frame_message) {
-    compositor_frame_.metadata = client_->MakeCompositorFrameMetadata();
-    output_device_->EndPaint(compositor_frame_.software_frame_data.get());
-  } else {
-    output_device_->EndPaint(NULL);
-  }
+
+  current_frame_data_.reset(new SoftwareFrameData);
+  output_device_->EndPaint(current_frame_data_.get());
 }
 
-void SoftwareRenderer::SwapBuffers(const ui::LatencyInfo& latency_info) {
-  if (Settings().compositor_frame_message)
-    output_surface_->SendFrameToParentCompositor(&compositor_frame_);
+void SoftwareRenderer::SwapBuffers() {
+  CompositorFrame compositor_frame;
+  compositor_frame.metadata = client_->MakeCompositorFrameMetadata();
+  compositor_frame.software_frame_data = current_frame_data_.Pass();
+  output_surface_->SwapBuffers(&compositor_frame);
 }
 
-void SoftwareRenderer::ReceiveCompositorFrameAck(
-    const CompositorFrameAck& ack) {
+void SoftwareRenderer::ReceiveSwapBuffersAck(const CompositorFrameAck& ack) {
   output_device_->ReclaimSoftwareFrame(ack.last_software_frame_id);
 }
 
 bool SoftwareRenderer::FlippedFramebuffer() const {
   return false;
 }
 
 void SoftwareRenderer::EnsureScissorTestEnabled() {
   is_scissor_enabled_ = true;
   SetClipRect(scissor_rect_);
@@ skipping 339 matching lines @@
                              4 * rect.width());
 }
 
 void SoftwareRenderer::SetVisible(bool visible) {
   if (visible_ == visible)
     return;
   visible_ = visible;
 }
 
 }  // namespace cc