Browser side changes for software compositing.

BUG=124671, 161008

NOTRY=true

Review URL: https://chromiumcodereview.appspot.com/13042012

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@192678 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 226 insertions, 85 deletions

diff --git a/content/browser/renderer_host/render_widget_host_impl.cc b/content/browser/renderer_host/render_widget_host_impl.cc
index 67ba418..eaabc71 100644
--- a/content/browser/renderer_host/render_widget_host_impl.cc
+++ b/content/browser/renderer_host/render_widget_host_impl.cc
@@ -1619,6 +1619,8 @@ bool RenderWidgetHostImpl::OnSwapCompositorFrame(
       ack.gl_frame_data->sync_point = 0;
     } else if (frame->delegated_frame_data) {
       ack.resources.swap(frame->delegated_frame_data->resource_list);
+    } else if (frame->software_frame_data) {
+      ack.last_dib_id = frame->software_frame_data->dib_id;
     }
     SendSwapCompositorFrameAck(routing_id_, process_->GetID(), ack);
   }
diff --git a/content/browser/renderer_host/render_widget_host_view_aura.cc b/content/browser/renderer_host/render_widget_host_view_aura.cc
index adc258a..6c2339f 100644
--- a/content/browser/renderer_host/render_widget_host_view_aura.cc
+++ b/content/browser/renderer_host/render_widget_host_view_aura.cc
@@ -927,7 +927,7 @@ bool RenderWidgetHostViewAura::HasFocus() const {
 }
 
 bool RenderWidgetHostViewAura::IsSurfaceAvailableForCopy() const {
-  return current_surface_ || !!host_->GetBackingStore(false);
+  return current_surface_ || current_dib_ || !!host_->GetBackingStore(false);
 }
 
 void RenderWidgetHostViewAura::Show() {
@@ -1228,13 +1228,13 @@ void RenderWidgetHostViewAura::OnAcceleratedCompositingStateChange() {
   accelerated_compositing_state_changed_ = true;
 }
 
-bool RenderWidgetHostViewAura::ShouldSkipFrame(gfx::Size size_in_dip) {
+bool RenderWidgetHostViewAura::ShouldSkipFrame(gfx::Size size_in_dip) const {
   if (can_lock_compositor_ == NO_PENDING_RENDERER_FRAME ||
       can_lock_compositor_ == NO_PENDING_COMMIT ||
       resize_locks_.empty())
     return false;
 
-  ResizeLockList::iterator it = resize_locks_.begin();
+  ResizeLockList::const_iterator it = resize_locks_.begin();
   while (it != resize_locks_.end()) {
     if ((*it)->expected_size() == size_in_dip)
       break;
@@ -1282,10 +1282,15 @@ void RenderWidgetHostViewAura::UpdateExternalTexture() {
   if (accelerated_compositing_state_changed_)
     accelerated_compositing_state_changed_ = false;
 
-  if (current_surface_ && host_->is_accelerated_compositing_active()) {
+  bool is_compositing_active = host_->is_accelerated_compositing_active();
+  if (is_compositing_active && current_surface_) {
     window_->SetExternalTexture(current_surface_.get());
     gfx::Size container_size = ConvertSizeToDIP(this, current_surface_->size());
     CheckResizeLocks(container_size);
+  } else if (is_compositing_active && current_dib_) {
+    window_->SetExternalTexture(NULL);
+    gfx::Size frame_size = ConvertSizeToDIP(this, last_swapped_surface_size_);
+    CheckResizeLocks(frame_size);
   } else {
     window_->SetExternalTexture(NULL);
     resize_locks_.clear();
@@ -1335,12 +1340,8 @@ void RenderWidgetHostViewAura::SwapBuffersCompleted(
   if (!compositor) {
     ack_callback.Run(false, texture_to_return);
   } else {
-    // Add sending an ACK to the list of things to do OnCompositingDidCommit
-    can_lock_compositor_ = NO_PENDING_COMMIT;
-    on_compositing_did_commit_callbacks_.push_back(
+    AddOnCommitCallbackAndDisableLocks(
         base::Bind(ack_callback, false, texture_to_return));
-    if (!compositor->HasObserver(this))
-      compositor->AddObserver(this);
   }
 }
 
@@ -1409,12 +1410,9 @@ void RenderWidgetHostViewAura::SwapDelegatedFrame(
   if (!compositor) {
     SendDelegatedFrameAck();
   } else {
-    can_lock_compositor_ = NO_PENDING_COMMIT;
-    on_compositing_did_commit_callbacks_.push_back(
+    AddOnCommitCallbackAndDisableLocks(
         base::Bind(&RenderWidgetHostViewAura::SendDelegatedFrameAck,
-                   base::Unretained(this)));
-    if (!compositor->HasObserver(this))
-      compositor->AddObserver(this);
+                   AsWeakPtr()));
   }
 }
 
@@ -1425,6 +1423,78 @@ void RenderWidgetHostViewAura::SendDelegatedFrameAck() {
       host_->GetRoutingID(), host_->GetProcess()->GetID(), ack);
 }
 
+void RenderWidgetHostViewAura::SwapSoftwareFrame(
+    scoped_ptr<cc::SoftwareFrameData> frame_data,
+    float frame_device_scale_factor) {
+  const gfx::Size& frame_size = frame_data->size;
+  const gfx::Rect& damage_rect = frame_data->damage_rect;
+  const TransportDIB::Id& dib_id = frame_data->dib_id;
+
+  scoped_ptr<TransportDIB> dib;
+#if defined(OS_WIN)
+  TransportDIB::Handle my_handle = TransportDIB::DefaultHandleValue();
+  ::DuplicateHandle(host_->GetProcess()->GetHandle(), dib_id.handle,
+                    ::GetCurrentProcess(), &my_handle,
+                    0, FALSE, DUPLICATE_SAME_ACCESS);
+  dib.reset(TransportDIB::Map(my_handle));
+#elif defined(USE_X11)
+  dib.reset(TransportDIB::Map(dib_id.shmkey));
+#else
+  NOTIMPLEMENTED();
+#endif
+
+  // Validate the received DIB.
+  size_t expected_size = 4 * frame_size.GetArea();
+  if (!dib || dib->size() < expected_size) {
+    host_->GetProcess()->ReceivedBadMessage();
+    return;
+  }
+
+  if (last_swapped_surface_size_ != frame_size) {
+    DLOG_IF(ERROR, damage_rect != gfx::Rect(frame_size))
+      << "Expected full damage rect";
+  }
+
+  TransportDIB::Id last_dib_id = current_dib_id_;
+  current_dib_.reset(dib.release());
+  current_dib_id_ = dib_id;
+  last_swapped_surface_size_ = frame_size;
+  previous_damage_.op(RectToSkIRect(damage_rect), SkRegion::kUnion_Op);
+
+  ui::Compositor* compositor = GetCompositor();
+  if (!compositor) {
+    SendSoftwareFrameAck(last_dib_id);
+    return;
+  }
+
+  gfx::Size frame_size_in_dip = gfx::ToFlooredSize(
+      gfx::ScaleSize(frame_size, 1.0f / frame_device_scale_factor));
+  if (ShouldSkipFrame(frame_size_in_dip)) {
+    can_lock_compositor_ = NO_PENDING_COMMIT;
+    SendSoftwareFrameAck(last_dib_id);
+  } else {
+    AddOnCommitCallbackAndDisableLocks(
+        base::Bind(&RenderWidgetHostViewAura::SendSoftwareFrameAck,
+                   AsWeakPtr(), last_dib_id));
+  }
+
+  CheckResizeLocks(frame_size_in_dip);
+  released_front_lock_ = NULL;
+  window_->SetExternalTexture(NULL);
+  window_->SchedulePaintInRect(ConvertRectToDIP(this, damage_rect));
+
+  if (paint_observer_)
+    paint_observer_->OnUpdateCompositorContent();
+}
+
+void RenderWidgetHostViewAura::SendSoftwareFrameAck(
+    const TransportDIB::Id& id) {
+  cc::CompositorFrameAck ack;
+  ack.last_dib_id = id;
+  RenderWidgetHostImpl::SendSwapCompositorFrameAck(
+      host_->GetRoutingID(), host_->GetProcess()->GetID(), ack);
+}
+
 void RenderWidgetHostViewAura::OnSwapCompositorFrame(
     scoped_ptr<cc::CompositorFrame> frame) {
   if (frame->delegated_frame_data) {
@@ -1432,6 +1502,13 @@ void RenderWidgetHostViewAura::OnSwapCompositorFrame(
                        frame->metadata.device_scale_factor);
     return;
   }
+
+  if (frame->software_frame_data) {
+    SwapSoftwareFrame(frame->software_frame_data.Pass(),
+                      frame->metadata.device_scale_factor);
+    return;
+  }
+
   if (!frame->gl_frame_data || frame->gl_frame_data->mailbox.IsZero())
     return;
 
@@ -1461,7 +1538,7 @@ void RenderWidgetHostViewAura::BuffersSwapped(
     const std::string& mailbox_name,
     const BufferPresentedCallback& ack_callback) {
   scoped_refptr<ui::Texture> texture_to_return(current_surface_);
-  const gfx::Rect surface_rect = gfx::Rect(gfx::Point(), size);
+  const gfx::Rect surface_rect = gfx::Rect(size);
   if (!SwapBuffersPrepare(
       surface_rect, surface_rect, mailbox_name, ack_callback)) {
     return;
@@ -1487,7 +1564,7 @@ void RenderWidgetHostViewAura::AcceleratedSurfacePostSubBuffer(
     int gpu_host_id) {
   scoped_refptr<ui::Texture> previous_texture(current_surface_);
   const gfx::Rect surface_rect =
-      gfx::Rect(gfx::Point(), params_in_pixel.surface_size);
+      gfx::Rect(params_in_pixel.surface_size);
   gfx::Rect damage_rect(params_in_pixel.x,
                         params_in_pixel.y,
                         params_in_pixel.width,
@@ -1561,15 +1638,12 @@ void RenderWidgetHostViewAura::AcceleratedSurfaceRelease() {
     if (compositor) {
       // We need to wait for a commit to clear to guarantee that all we
       // will not issue any more GL referencing the previous surface.
-      can_lock_compositor_ = NO_PENDING_COMMIT;
-      on_compositing_did_commit_callbacks_.push_back(
+      AddOnCommitCallbackAndDisableLocks(
           base::Bind(&RenderWidgetHostViewAura::
                      SetSurfaceNotInUseByCompositor,
                      AsWeakPtr(),
                      current_surface_));  // Hold a ref so the texture will not
                                           // get deleted until after commit.
-      if (!compositor->HasObserver(this))
-        compositor->AddObserver(this);
     }
     current_surface_ = NULL;
     UpdateExternalTexture();
@@ -1952,12 +2026,47 @@ void RenderWidgetHostViewAura::OnCaptureLost() {
 }
 
 void RenderWidgetHostViewAura::OnPaint(gfx::Canvas* canvas) {
-  paint_canvas_ = canvas;
-  BackingStore* backing_store = host_->GetBackingStore(true);
-  paint_canvas_ = NULL;
-  if (backing_store) {
-    static_cast<BackingStoreAura*>(backing_store)->SkiaShowRect(gfx::Point(),
-                                                                canvas);
+  bool is_compositing_active = host_->is_accelerated_compositing_active();
+  bool has_backing_store = !!host_->GetBackingStore(false);
+  if (is_compositing_active && current_dib_) {
+    const gfx::Size window_size = window_->bounds().size();
+    const gfx::Size& frame_size = last_swapped_surface_size_;
+
+    SkBitmap bitmap;
+    bitmap.setConfig(SkBitmap::kARGB_8888_Config,
+                     frame_size.width(),
+                     frame_size.height());
+    bitmap.setPixels(current_dib_->memory());
+
+    SkCanvas* sk_canvas = canvas->sk_canvas();
+    for (SkRegion::Iterator it(previous_damage_); !it.done(); it.next()) {
+      const SkIRect& src_rect = it.rect();
+      SkRect dst_rect = SkRect::Make(src_rect);
+      sk_canvas->drawBitmapRect(bitmap, &src_rect, dst_rect, NULL);
+    }
+    previous_damage_.setEmpty();
+
+    if (frame_size != window_size) {
+      SkRegion region;
+      region.op(0, 0, window_size.width(), window_size.height(),
+                SkRegion::kUnion_Op);
+      region.op(0, 0, frame_size.width(), frame_size.height(),
+                SkRegion::kDifference_Op);
+      SkPaint paint;
+      paint.setColor(SK_ColorWHITE);
+      for (SkRegion::Iterator it(region); !it.done(); it.next())
+        sk_canvas->drawIRect(it.rect(), paint);
+    }
+
+    if (paint_observer_)
+      paint_observer_->OnPaintComplete();
+  } else if (!is_compositing_active && has_backing_store) {
+    paint_canvas_ = canvas;
+    BackingStoreAura* backing_store = static_cast<BackingStoreAura*>(
+        host_->GetBackingStore(true));
+    paint_canvas_ = NULL;
+    backing_store->SkiaShowRect(gfx::Point(), canvas);
+
     if (paint_observer_)
       paint_observer_->OnPaintComplete();
   } else if (aura::Env::GetInstance()->render_white_bg()) {
@@ -2375,7 +2484,7 @@ void RenderWidgetHostViewAura::OnCompositingDidCommit(
       if ((*it)->GrabDeferredLock())
         can_lock_compositor_ = YES_DID_LOCK;
   }
-  RunCompositingDidCommitCallbacks();
+  RunOnCommitCallbacks();
   locks_pending_commit_.clear();
 }
 
@@ -2474,7 +2583,7 @@ void RenderWidgetHostViewAura::OnLostResources() {
   // Make sure all ImageTransportClients are deleted now that the context those
   // are using is becoming invalid. This sends pending ACKs and needs to happen
   // after calling UpdateExternalTexture() which syncs with the impl thread.
-  RunCompositingDidCommitCallbacks();
+  RunOnCommitCallbacks();
 
   DCHECK(!shared_surface_handle_.is_null());
   ImageTransportFactory* factory = ImageTransportFactory::GetInstance();
@@ -2630,7 +2739,7 @@ bool RenderWidgetHostViewAura::ShouldMoveToCenter() {
       global_mouse_position_.y() > rect.bottom() - border_y;
 }
 
-void RenderWidgetHostViewAura::RunCompositingDidCommitCallbacks() {
+void RenderWidgetHostViewAura::RunOnCommitCallbacks() {
   for (std::vector<base::Closure>::const_iterator
       it = on_compositing_did_commit_callbacks_.begin();
       it != on_compositing_did_commit_callbacks_.end(); ++it) {
@@ -2639,6 +2748,18 @@ void RenderWidgetHostViewAura::RunCompositingDidCommitCallbacks() {
   on_compositing_did_commit_callbacks_.clear();
 }
 
+void RenderWidgetHostViewAura::AddOnCommitCallbackAndDisableLocks(
+    const base::Closure& callback) {
+  ui::Compositor* compositor = GetCompositor();
+  DCHECK(compositor);
+
+  if (!compositor->HasObserver(this))
+    compositor->AddObserver(this);
+
+  can_lock_compositor_ = NO_PENDING_COMMIT;
+  on_compositing_did_commit_callbacks_.push_back(callback);
+}
+
 void RenderWidgetHostViewAura::AddedToRootWindow() {
   window_->GetRootWindow()->AddRootWindowObserver(this);
   host_->ParentChanged(GetNativeViewId());
@@ -2658,7 +2779,7 @@ void RenderWidgetHostViewAura::RemovingFromRootWindow() {
   // frame though, because we will reissue a new frame right away without that
   // composited data.
   ui::Compositor* compositor = GetCompositor();
-  RunCompositingDidCommitCallbacks();
+  RunOnCommitCallbacks();
   locks_pending_commit_.clear();
   if (compositor && compositor->HasObserver(this))
     compositor->RemoveObserver(this);
diff --git a/content/browser/renderer_host/render_widget_host_view_aura.h b/content/browser/renderer_host/render_widget_host_view_aura.h
index 52c6376..8464d88 100644
--- a/content/browser/renderer_host/render_widget_host_view_aura.h
+++ b/content/browser/renderer_host/render_widget_host_view_aura.h
@@ -316,7 +316,7 @@ class RenderWidgetHostViewAura
   virtual ~RenderWidgetHostViewAura();
 
   void UpdateCursorIfOverSelf();
-  bool ShouldSkipFrame(gfx::Size size_in_dip);
+  bool ShouldSkipFrame(gfx::Size size_in_dip) const;
   void CheckResizeLocks(gfx::Size size_in_dip);
   void UpdateExternalTexture();
   ui::InputMethod* GetInputMethod() const;
@@ -340,8 +340,11 @@ class RenderWidgetHostViewAura
   // moved to center.
   bool ShouldMoveToCenter();
 
-  // Run the compositing callbacks.
-  void RunCompositingDidCommitCallbacks();
+  // Run all on compositing commit callbacks.
+  void RunOnCommitCallbacks();
+
+  // Add on compositing commit callback.
+  void AddOnCommitCallbackAndDisableLocks(const base::Closure& callback);
 
   // Called after |window_| is parented to a RootWindow.
   void AddedToRootWindow();
@@ -391,10 +394,15 @@ class RenderWidgetHostViewAura
       const scoped_refptr<ui::Texture>& texture_to_return);
 
   void SwapDelegatedFrame(
-      scoped_ptr<cc::DelegatedFrameData> frame,
-      float device_scale_factor);
+      scoped_ptr<cc::DelegatedFrameData> frame_data,
+      float frame_device_scale_factor);
   void SendDelegatedFrameAck();
 
+  void SwapSoftwareFrame(
+      scoped_ptr<cc::SoftwareFrameData> frame_data,
+      float frame_device_scale_factor);
+  void SendSoftwareFrameAck(const TransportDIB::Id& id);
+
   BrowserAccessibilityManager* GetOrCreateBrowserAccessibilityManager();
 
 #if defined(OS_WIN)
@@ -471,6 +479,13 @@ class RenderWidgetHostViewAura
   // The current frontbuffer texture.
   scoped_refptr<ui::Texture> current_surface_;
 
+  // The current frontbuffer DIB.
+  scoped_ptr<TransportDIB> current_dib_;
+
+  // The current DIB id as it was received from the renderer. Note that on
+  // some platforms (e.g. Windows) this is different from current_dib_->id().
+  TransportDIB::Id current_dib_id_;
+
   // The damage in the previously presented buffer.
   SkRegion previous_damage_;
 
diff --git a/content/renderer/gpu/compositor_software_output_device.cc b/content/renderer/gpu/compositor_software_output_device.cc
index 77fbdb3..3fdf807 100644
--- a/content/renderer/gpu/compositor_software_output_device.cc
+++ b/content/renderer/gpu/compositor_software_output_device.cc
@@ -32,8 +32,7 @@ class CompareById {
 }  // namespace
 
 CompositorSoftwareOutputDevice::CompositorSoftwareOutputDevice()
-    : front_buffer_(0),
-      last_buffer_(-1),
+    : front_buffer_(-1),
       num_free_buffers_(0),
       sequence_num_(0) {
   DetachFromThread();
@@ -55,38 +54,44 @@ TransportDIB* CompositorSoftwareOutputDevice::CreateDIB() {
 void CompositorSoftwareOutputDevice::Resize(gfx::Size viewport_size) {
   DCHECK(CalledOnValidThread());
 
-  // Reset last_buffer_ so that we don't copy over old damage.
-  last_buffer_ = -1;
-
   if (viewport_size_ == viewport_size)
     return;
-  viewport_size_ = viewport_size;
 
-  // Keep non-acked dibs open.
-  for (size_t i = 0; i < dibs_.size() - num_free_buffers_; ++i) {
-    size_t index = (front_buffer_ + num_free_buffers_ + i) % dibs_.size();
+  // Keep non-ACKed dibs open.
+  int first_non_free = front_buffer_ + num_free_buffers_ + 1;
+  int num_non_free = dibs_.size() - num_free_buffers_;
+  for (int i = 0; i < num_non_free; ++i) {
+    int index = (first_non_free + i) % dibs_.size();
     awaiting_ack_.push_back(dibs_[index]);
     dibs_[index] = NULL;
   }
 
   dibs_.clear();
-  front_buffer_ = 0;
+  front_buffer_ = -1;
   num_free_buffers_ = 0;
+  viewport_size_ = viewport_size;
 }
 
 SkCanvas* CompositorSoftwareOutputDevice::BeginPaint(gfx::Rect damage_rect) {
   DCHECK(CalledOnValidThread());
 
+  gfx::Rect last_damage_rect = damage_rect_;
+  damage_rect_ = damage_rect;
+
+  int last_buffer = front_buffer_;
   if (num_free_buffers_ == 0) {
-    dibs_.insert(dibs_.begin() + front_buffer_, CreateDIB());
-    num_free_buffers_++;
+    dibs_.insert(dibs_.begin() + (front_buffer_ + 1), CreateDIB());
+    last_damage_rect = gfx::Rect(viewport_size_);
+  } else {
+    --num_free_buffers_;
   }
+  front_buffer_ = (front_buffer_ + 1) % dibs_.size();
 
   TransportDIB* front_dib = dibs_[front_buffer_];
   DCHECK(front_dib);
   DCHECK(front_dib->memory());
 
-  // Set up a canvas for the front_dib.
+  // Set up a canvas for the current front buffer.
   bitmap_.setConfig(SkBitmap::kARGB_8888_Config,
                     viewport_size_.width(),
                     viewport_size_.height());
@@ -94,19 +99,23 @@ SkCanvas* CompositorSoftwareOutputDevice::BeginPaint(gfx::Rect damage_rect) {
   device_ = skia::AdoptRef(new SkDevice(bitmap_));
   canvas_ = skia::AdoptRef(new SkCanvas(device_.get()));
 
-  // Copy damage_rect_ from last_buffer_ to front_buffer_.
-  if (last_buffer_ != -1 && !damage_rect.Contains(damage_rect_)) {
-    TransportDIB* last_dib = dibs_[last_buffer_];
+  // Copy over previous damage.
+  if (last_buffer != -1) {
+    TransportDIB* last_dib = dibs_[last_buffer];
     SkBitmap back_bitmap;
     back_bitmap.setConfig(SkBitmap::kARGB_8888_Config,
                           viewport_size_.width(),
                           viewport_size_.height());
     back_bitmap.setPixels(last_dib->memory());
 
-    SkRect last_damage = gfx::RectToSkRect(damage_rect_);
-    canvas_->drawBitmapRectToRect(back_bitmap, &last_damage, last_damage, NULL);
+    SkRegion region(RectToSkIRect(last_damage_rect));
+    region.op(RectToSkIRect(damage_rect), SkRegion::kDifference_Op);
+    for (SkRegion::Iterator it(region); !it.done(); it.next()) {
+      const SkIRect& src_rect = it.rect();
+      SkRect dst_rect = SkRect::Make(src_rect);
+      canvas_->drawBitmapRect(back_bitmap, &src_rect, dst_rect, NULL);
+    }
   }
-  damage_rect_ = damage_rect;
 
   return canvas_.get();
 }
@@ -120,30 +129,28 @@ void CompositorSoftwareOutputDevice::EndPaint(
     frame_data->damage_rect = damage_rect_;
     frame_data->dib_id = dibs_[front_buffer_]->id();
   }
-
-  last_buffer_ = front_buffer_;
-  front_buffer_ = (front_buffer_ + 1) % dibs_.size();
-  --num_free_buffers_;
-  DCHECK_GE(num_free_buffers_, 0);
 }
 
 void CompositorSoftwareOutputDevice::ReclaimDIB(const TransportDIB::Id& id) {
   DCHECK(CalledOnValidThread());
 
-  // The reclaimed handle might not be among the currently
+  if (!TransportDIB::is_valid_id(id))
+    return;
+
+  // The reclaimed dib id might not be among the currently
   // active dibs if we got a resize event in the mean time.
   ScopedVector<TransportDIB>::iterator it =
       std::find_if(dibs_.begin(), dibs_.end(), CompareById(id));
   if (it != dibs_.end()) {
     ++num_free_buffers_;
+    DCHECK_LE(static_cast<size_t>(num_free_buffers_), dibs_.size());
+    return;
   } else {
-    it = std::find_if(awaiting_ack_.begin(),
-                      awaiting_ack_.end(),
+    it = std::find_if(awaiting_ack_.begin(), awaiting_ack_.end(),
                       CompareById(id));
+    DCHECK(it != awaiting_ack_.end());
     awaiting_ack_.erase(it);
   }
-
-  DCHECK_LE(static_cast<size_t>(num_free_buffers_), dibs_.size());
 }
 
 }  // namespace content
diff --git a/content/renderer/gpu/compositor_software_output_device.h b/content/renderer/gpu/compositor_software_output_device.h
index a639347..dba05d9 100644
--- a/content/renderer/gpu/compositor_software_output_device.h
+++ b/content/renderer/gpu/compositor_software_output_device.h
@@ -33,7 +33,6 @@ private:
   TransportDIB* CreateDIB();
 
   int front_buffer_;
-  int last_buffer_;
   int num_free_buffers_;
   ScopedVector<TransportDIB> dibs_;
   ScopedVector<TransportDIB> awaiting_ack_;
diff --git a/content/renderer/render_widget.cc b/content/renderer/render_widget.cc
index 16872d8..b32b327 100644
--- a/content/renderer/render_widget.cc
+++ b/content/renderer/render_widget.cc
@@ -24,7 +24,7 @@
 #include "content/common/view_messages.h"
 #include "content/public/common/content_switches.h"
 #include "content/renderer/gpu/compositor_output_surface.h"
-#include "content/renderer/gpu/compositor_software_output_device_gl_adapter.h"
+#include "content/renderer/gpu/compositor_software_output_device.h"
 #include "content/renderer/gpu/input_handler_manager.h"
 #include "content/renderer/gpu/mailbox_output_surface.h"
 #include "content/renderer/gpu/render_widget_compositor.h"
@@ -555,6 +555,13 @@ bool RenderWidget::ForceCompositingModeEnabled() {
 }
 
 scoped_ptr<cc::OutputSurface> RenderWidget::CreateOutputSurface() {
+  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+  if (command_line.HasSwitch(switches::kEnableSoftwareCompositingGLAdapter)) {
+      return scoped_ptr<cc::OutputSurface>(
+          new CompositorOutputSurface(routing_id(), NULL,
+              new CompositorSoftwareOutputDevice()));
+  }
+
   // Explicitly disable antialiasing for the compositor. As of the time of
   // this writing, the only platform that supported antialiasing for the
   // compositor was Mac OS X, because the on-screen OpenGL context creation
@@ -573,25 +580,15 @@ scoped_ptr<cc::OutputSurface> RenderWidget::CreateOutputSurface() {
   if (!context)
     return scoped_ptr<cc::OutputSurface>();
 
-  const CommandLine& command_line = *CommandLine::ForCurrentProcess();
-  if (command_line.HasSwitch(switches::kEnableSoftwareCompositingGLAdapter)) {
-      // In the absence of a software-based delegating renderer, use this
-      // stopgap adapter class to present the software renderer output using a
-      // 3d context.
-      return scoped_ptr<cc::OutputSurface>(
-          new CompositorOutputSurface(routing_id(), NULL,
-              new CompositorSoftwareOutputDeviceGLAdapter(context)));
-  } else {
-      bool composite_to_mailbox =
-          command_line.HasSwitch(cc::switches::kCompositeToMailbox);
-      DCHECK(!composite_to_mailbox || command_line.HasSwitch(
-          cc::switches::kEnableCompositorFrameMessage));
-      // No swap throttling yet when compositing on the main thread.
-      DCHECK(!composite_to_mailbox || is_threaded_compositing_enabled_);
-      return scoped_ptr<cc::OutputSurface>(composite_to_mailbox ?
-          new MailboxOutputSurface(routing_id(), context, NULL) :
-              new CompositorOutputSurface(routing_id(), context, NULL));
-  }
+  bool composite_to_mailbox =
+      command_line.HasSwitch(cc::switches::kCompositeToMailbox);
+  DCHECK(!composite_to_mailbox || command_line.HasSwitch(
+      cc::switches::kEnableCompositorFrameMessage));
+  // No swap throttling yet when compositing on the main thread.
+  DCHECK(!composite_to_mailbox || is_threaded_compositing_enabled_);
+  return scoped_ptr<cc::OutputSurface>(composite_to_mailbox ?
+      new MailboxOutputSurface(routing_id(), context, NULL) :
+          new CompositorOutputSurface(routing_id(), context, NULL));
 }
 
 void RenderWidget::OnViewContextSwapBuffersAborted() {