Mac: Kill lots of AcceleratedWidget code (with fire)

content/browser/compositor/software_output_device_mac.mm

 // Copyright 2014 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.
 
 #import <Cocoa/Cocoa.h>
 
 #include "content/browser/compositor/software_output_device_mac.h"
 
+#include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/accelerated_widget_mac/accelerated_widget_mac.h"
 #include "ui/compositor/compositor.h"
+#include "ui/gfx/skia_util.h"
 
 namespace content {
 
 SoftwareOutputDeviceMac::SoftwareOutputDeviceMac(ui::Compositor* compositor)
-    : compositor_(compositor) {
-}
+    : compositor_(compositor), scale_factor_(1), current_index_(0) {}
 
 SoftwareOutputDeviceMac::~SoftwareOutputDeviceMac() {
 }
 
+void SoftwareOutputDeviceMac::Resize(const gfx::Size& pixel_size,
+                                     float scale_factor) {
+  if (pixel_size_ == pixel_size && scale_factor_ == scale_factor)
+    return;
+
+  pixel_size_ = pixel_size;
+  scale_factor_ = scale_factor;
+
+  DiscardBackbuffer();
+}
+
+void SoftwareOutputDeviceMac::CopyPreviousBufferDamage(
+    const gfx::Rect& new_damage_rect) {
+  TRACE_EVENT0("browser", "CopyPreviousBufferDamage");
+
+  // The region to copy is the region drawn last frame, minus the region that
+  // is drawn this frame.
+  SkRegion copy_region(
+      SkRegion(gfx::RectToSkIRect(previous_buffer_damage_rect_)));
+  bool copy_region_nonempty = copy_region.op(
+      gfx::RectToSkIRect(new_damage_rect), SkRegion::kDifference_Op);
+  previous_buffer_damage_rect_ = new_damage_rect;
+
+  if (!copy_region_nonempty)
+    return;
+
+  {
+    TRACE_EVENT0("browser", "IOSurfaceLock");
+    IOReturn io_result = IOSurfaceLock(
+        io_surfaces_[!current_index_],
+        kIOSurfaceLockReadOnly | kIOSurfaceLockAvoidSync, nullptr);
+    if (io_result) {
+      LOG(ERROR) << "Failed to lock previous IOSurface " << io_result;
+      return;
+    }
+  }
+
+  uint8_t* pixels = reinterpret_cast<uint8_t*>(
+      IOSurfaceGetBaseAddress(io_surfaces_[!current_index_]));
+  size_t pitch = IOSurfaceGetBytesPerRow(io_surfaces_[!current_index_]);
+  size_t bytes_per_element = 4;
+  for (SkRegion::Iterator it(copy_region); !it.done(); it.next()) {
+    const SkIRect& rect = it.rect();
+    canvas_->writePixels(
+        SkImageInfo::MakeN32Premul(rect.width(), rect.height()),
+        pixels + bytes_per_element * rect.x() + pitch * rect.y(), pitch,
+        rect.x(), rect.y());
+  }
+
+  {
+    TRACE_EVENT0("browser", "IOSurfaceUnlock");
+    IOReturn io_result = IOSurfaceUnlock(
+        io_surfaces_[!current_index_],
+        kIOSurfaceLockReadOnly | kIOSurfaceLockAvoidSync, nullptr);
+    if (io_result) {
+      LOG(ERROR) << "Failed to unlock previous IOSurface " << io_result;
+    }
+  }
+}
+
+SkCanvas* SoftwareOutputDeviceMac::BeginPaint(
+    const gfx::Rect& new_damage_rect) {
+  for (int i = 0; i < 2; ++i) {
+    if (!io_surfaces_[i]) {
+      TRACE_EVENT0("browser", "IOSurfaceCreate");
+      unsigned pixelFormat = 'BGRA';
+      unsigned bytesPerElement = 4;
+      NSDictionary* options = @{
+        (id) kIOSurfaceWidth : @(pixel_size_.width()), (id)
+        kIOSurfaceHeight : @(pixel_size_.height()), (id)
+        kIOSurfacePixelFormat : @(pixelFormat), (id)
+        kIOSurfaceBytesPerElement : @(bytesPerElement),
+      };
+      io_surfaces_[i].reset(IOSurfaceCreate((CFDictionaryRef)options));
+    }
+    if (!io_surfaces_[i]) {
+      LOG(ERROR) << "Failed to allocateIOSurface";
+      return nullptr;
+    }
+  }
+
+  {
+    TRACE_EVENT0("browser", "IOSurfaceLock");
+    IOReturn io_result = IOSurfaceLock(io_surfaces_[current_index_],
+                                       kIOSurfaceLockAvoidSync, nullptr);
+    if (io_result) {
+      LOG(ERROR) << "Failed to lock IOSurface " << io_result;
+      return nullptr;
+    }
+  }
+
+  SkPMColor* pixels = reinterpret_cast<SkPMColor*>(
+      IOSurfaceGetBaseAddress(io_surfaces_[current_index_]));
+  size_t pitch = IOSurfaceGetBytesPerRow(io_surfaces_[current_index_]);
+
+  canvas_ = skia::AdoptRef(SkCanvas::NewRasterDirectN32(
+      pixel_size_.width(), pixel_size_.height(), pixels, pitch));
+
+  CopyPreviousBufferDamage(new_damage_rect);
+  return canvas_.get();
+}
+
 void SoftwareOutputDeviceMac::EndPaint() {
   SoftwareOutputDevice::EndPaint();
-  ui::AcceleratedWidgetMacGotSoftwareFrame(
-      compositor_->widget(), scale_factor_, surface_->getCanvas());
+  {
+    TRACE_EVENT0("browser", "IOSurfaceUnlock");
+    IOReturn io_result = IOSurfaceUnlock(io_surfaces_[current_index_],
+                                         kIOSurfaceLockAvoidSync, nullptr);
+    if (io_result) {
+      LOG(ERROR) << "Failed to unlock IOSurface " << io_result;
+    }
+  }
+
+  canvas_ = nullptr;
+  ui::AcceleratedWidgetMacGotIOSurfaceFrame(compositor_->widget(),
+                                            io_surfaces_[current_index_],
+                                            pixel_size_, scale_factor_, false);
+
+  current_index_ += 1;
+  current_index_ %= 2;
 }
 
+void SoftwareOutputDeviceMac::DiscardBackbuffer() {
+  for (int i = 0; i < 2; ++i)
+    io_surfaces_[i].reset();
+}
+
+void SoftwareOutputDeviceMac::EnsureBackbuffer() {}
+
 }  // namespace content