path: root/content/browser/renderer_host/backing_store_mac.mm

// Copyright (c) 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.

#import <Cocoa/Cocoa.h>

#include "content/browser/renderer_host/backing_store_mac.h"

#include <cmath>

#include "base/logging.h"
#include "base/mac/mac_util.h"
#include "base/mac/scoped_cftyperef.h"
#include "content/browser/renderer_host/render_process_host_impl.h"
#include "content/browser/renderer_host/render_widget_host_impl.h"
#include "content/public/browser/render_widget_host_view.h"
#include "skia/ext/platform_canvas.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "third_party/skia/include/core/SkCanvas.h"
#include "ui/gfx/rect.h"
#include "ui/gfx/rect_conversions.h"
#include "ui/gfx/size_conversions.h"
#include "ui/gfx/scoped_cg_context_save_gstate_mac.h"
#include "ui/surface/transport_dib.h"

namespace content {

// Mac Backing Stores:
//
// Since backing stores are only ever written to or drawn into windows, we keep
// our backing store in a CGLayer that can get cached in GPU memory.  This
// allows acclerated drawing into the layer and lets scrolling and such happen
// all or mostly on the GPU, which is good for performance.

BackingStoreMac::BackingStoreMac(RenderWidgetHost* widget,
                                 const gfx::Size& size,
                                 float device_scale_factor)
    : BackingStore(widget, size), device_scale_factor_(device_scale_factor) {
  cg_layer_.reset(CreateCGLayer());
  if (!cg_layer_) {
    // The view isn't in a window yet.  Use a CGBitmapContext for now.
    cg_bitmap_.reset(CreateCGBitmapContext());
    CGContextScaleCTM(cg_bitmap_, device_scale_factor_, device_scale_factor_);
  }
}

BackingStoreMac::~BackingStoreMac() {
}

void BackingStoreMac::ScaleFactorChanged(float device_scale_factor) {
  if (device_scale_factor == device_scale_factor_)
    return;

  device_scale_factor_ = device_scale_factor;

  base::ScopedCFTypeRef<CGLayerRef> new_layer(CreateCGLayer());
  // If we have a layer, copy the old contents. A pixelated flash is better
  // than a white flash.
  if (new_layer && cg_layer_) {
    CGContextRef layer = CGLayerGetContext(new_layer);
    CGContextDrawLayerAtPoint(layer, CGPointMake(0, 0), cg_layer_);
  }

  cg_layer_.swap(new_layer);
  if (!cg_layer_) {
    // The view isn't in a window yet.  Use a CGBitmapContext for now.
    cg_bitmap_.reset(CreateCGBitmapContext());
    CGContextScaleCTM(cg_bitmap_, device_scale_factor_, device_scale_factor_);
  }
}

size_t BackingStoreMac::MemorySize() {
  return gfx::ToFlooredSize(
      gfx::ScaleSize(size(), device_scale_factor_)).GetArea() * 4;
}

void BackingStoreMac::PaintToBackingStore(
    RenderProcessHost* process,
    TransportDIB::Id bitmap,
    const gfx::Rect& bitmap_rect,
    const std::vector<gfx::Rect>& copy_rects,
    float scale_factor,
    const base::Closure& completion_callback,
    bool* scheduled_completion_callback) {
  *scheduled_completion_callback = false;
  DCHECK_NE(static_cast<bool>(cg_layer()), static_cast<bool>(cg_bitmap()));

  TransportDIB* dib = process->GetTransportDIB(bitmap);
  if (!dib)
    return;

  gfx::Size pixel_size = gfx::ToFlooredSize(
      gfx::ScaleSize(size(), device_scale_factor_));
  gfx::Rect pixel_bitmap_rect = ToFlooredRectDeprecated(
      gfx::ScaleRect(bitmap_rect, scale_factor));

  size_t bitmap_byte_count =
      pixel_bitmap_rect.width() * pixel_bitmap_rect.height() * 4;
  DCHECK_GE(dib->size(), bitmap_byte_count);

  base::ScopedCFTypeRef<CGDataProviderRef> data_provider(
      CGDataProviderCreateWithData(
          NULL, dib->memory(), bitmap_byte_count, NULL));

  base::ScopedCFTypeRef<CGImageRef> bitmap_image(
      CGImageCreate(pixel_bitmap_rect.width(),
                    pixel_bitmap_rect.height(),
                    8,
                    32,
                    4 * pixel_bitmap_rect.width(),
                    base::mac::GetSystemColorSpace(),
                    kCGImageAlphaPremultipliedFirst | kCGBitmapByteOrder32Host,
                    data_provider,
                    NULL,
                    false,
                    kCGRenderingIntentDefault));

  for (size_t i = 0; i < copy_rects.size(); i++) {
    const gfx::Rect& copy_rect = copy_rects[i];
    gfx::Rect pixel_copy_rect = ToFlooredRectDeprecated(
        gfx::ScaleRect(copy_rect, scale_factor));

    // Only the subpixels given by copy_rect have pixels to copy.
    base::ScopedCFTypeRef<CGImageRef> image(CGImageCreateWithImageInRect(
        bitmap_image,
        CGRectMake(pixel_copy_rect.x() - pixel_bitmap_rect.x(),
                   pixel_copy_rect.y() - pixel_bitmap_rect.y(),
                   pixel_copy_rect.width(),
                   pixel_copy_rect.height())));

    if (!cg_layer()) {
      // The view may have moved to a window.  Try to get a CGLayer.
      cg_layer_.reset(CreateCGLayer());
      if (cg_layer()) {
        // Now that we have a layer, copy the cached image into it.
        base::ScopedCFTypeRef<CGImageRef> bitmap_image(
            CGBitmapContextCreateImage(cg_bitmap_));
        CGContextDrawImage(CGLayerGetContext(cg_layer()),
                           CGRectMake(0, 0, size().width(), size().height()),
                           bitmap_image);
        // Discard the cache bitmap, since we no longer need it.
        cg_bitmap_.reset(NULL);
      }
    }

    DCHECK_NE(static_cast<bool>(cg_layer()), static_cast<bool>(cg_bitmap()));

    if (cg_layer()) {
      // The CGLayer's origin is in the lower left, but flipping the CTM would
      // cause the image to get drawn upside down.  So we move the rectangle
      // to the right position before drawing the image.
      CGContextRef layer = CGLayerGetContext(cg_layer());
      gfx::Rect paint_rect = copy_rect;
      paint_rect.set_y(size().height() - copy_rect.bottom());
      CGContextDrawImage(layer, paint_rect.ToCGRect(), image);
    } else {
      // The layer hasn't been created yet, so draw into the cache bitmap.
      gfx::Rect paint_rect = copy_rect;
      paint_rect.set_y(size().height() - copy_rect.bottom());
      CGContextDrawImage(cg_bitmap_, paint_rect.ToCGRect(), image);
    }
  }
}

bool BackingStoreMac::CopyFromBackingStore(const gfx::Rect& rect,
                                           skia::PlatformBitmap* output) {
  // TODO(thakis): Make sure this works with HiDPI backing stores.
  if (!output->Allocate(rect.width(), rect.height(), true))
    return false;

  CGContextRef temp_context = output->GetSurface();
  gfx::ScopedCGContextSaveGState save_gstate(temp_context);
  CGContextTranslateCTM(temp_context, 0.0, size().height());
  CGContextScaleCTM(temp_context, 1.0, -1.0);
  if (cg_layer()) {
    CGContextDrawLayerAtPoint(temp_context, CGPointMake(-rect.x(), -rect.y()),
                              cg_layer());
  } else {
    base::ScopedCFTypeRef<CGImageRef> bitmap_image(
        CGBitmapContextCreateImage(cg_bitmap_));
    CGContextDrawImage(
        temp_context,
        CGRectMake(-rect.x(), -rect.y(), rect.width(), rect.height()),
        bitmap_image);
  }

  return true;
}

// Scroll the contents of our CGLayer
void BackingStoreMac::ScrollBackingStore(const gfx::Vector2d& delta,
                                         const gfx::Rect& clip_rect,
                                         const gfx::Size& view_size) {
  DCHECK_NE(static_cast<bool>(cg_layer()), static_cast<bool>(cg_bitmap()));

  // "Scroll" the contents of the layer by creating a new CGLayer,
  // copying the contents of the old one into the new one offset by the scroll
  // amount, swapping in the new CGLayer, and then painting in the new data.
  //
  // The Windows code always sets the whole backing store as the source of the
  // scroll. Thus, we only have to worry about pixels which will end up inside
  // the clipping rectangle. (Note that the clipping rectangle is not
  // translated by the scroll.)

  // We assume |clip_rect| is contained within the backing store.
  DCHECK(clip_rect.bottom() <= size().height());
  DCHECK(clip_rect.right() <= size().width());

  if ((delta.x() || delta.y()) &&
       abs(delta.x()) < size().width() && abs(delta.y()) < size().height()) {
    if (cg_layer()) {
      CGContextRef layer = CGLayerGetContext(cg_layer());
      gfx::ScopedCGContextSaveGState save_gstate(layer);
      CGContextClipToRect(layer,
                          CGRectMake(clip_rect.x(),
                                     size().height() - clip_rect.bottom(),
                                     clip_rect.width(),
                                     clip_rect.height()));
      CGContextDrawLayerAtPoint(layer,
                                CGPointMake(delta.x(), -delta.y()), cg_layer());
    } else {
      // We don't have a layer, so scroll the contents of the CGBitmapContext.
      base::ScopedCFTypeRef<CGImageRef> bitmap_image(
          CGBitmapContextCreateImage(cg_bitmap_));
      gfx::ScopedCGContextSaveGState save_gstate(cg_bitmap_);
      CGContextClipToRect(cg_bitmap_,
                          CGRectMake(clip_rect.x(),
                                     size().height() - clip_rect.bottom(),
                                     clip_rect.width(),
                                     clip_rect.height()));
      CGContextDrawImage(cg_bitmap_,
                         CGRectMake(delta.x(), -delta.y(),
                                    size().width(), size().height()),
                         bitmap_image);
    }
  }
}

void BackingStoreMac::CopyFromBackingStoreToCGContext(const CGRect& dest_rect,
                                                      CGContextRef context) {
  gfx::ScopedCGContextSaveGState save_gstate(context);
  CGContextSetInterpolationQuality(context, kCGInterpolationHigh);
  if (cg_layer_) {
    CGContextDrawLayerInRect(context, dest_rect, cg_layer_);
  } else {
    base::ScopedCFTypeRef<CGImageRef> image(
        CGBitmapContextCreateImage(cg_bitmap_));
    CGContextDrawImage(context, dest_rect, image);
  }
}

CGLayerRef BackingStoreMac::CreateCGLayer() {
  // The CGLayer should be optimized for drawing into the containing window,
  // so extract a CGContext corresponding to the window to be passed to
  // CGLayerCreateWithContext.
  NSWindow* window = [render_widget_host()->GetView()->GetNativeView() window];
  if ([window windowNumber] <= 0) {
    // This catches a nil |window|, as well as windows that exist but that
    // aren't yet connected to WindowServer.
    return NULL;
  }

  NSGraphicsContext* ns_context = [window graphicsContext];
  DCHECK(ns_context);

  CGContextRef cg_context = static_cast<CGContextRef>(
      [ns_context graphicsPort]);
  DCHECK(cg_context);

  // Note: This takes the backingScaleFactor of cg_context into account. The
  // bitmap backing |layer| will be size() * 2 in HiDPI mode automatically.
  CGLayerRef layer = CGLayerCreateWithContext(cg_context,
                                              size().ToCGSize(),
                                              NULL);
  DCHECK(layer);

  return layer;
}

CGContextRef BackingStoreMac::CreateCGBitmapContext() {
  gfx::Size pixel_size = gfx::ToFlooredSize(
      gfx::ScaleSize(size(), device_scale_factor_));
  // A CGBitmapContext serves as a stand-in for the layer before the view is
  // in a containing window.
  CGContextRef context = CGBitmapContextCreate(NULL,
                                               pixel_size.width(),
                                               pixel_size.height(),
                                               8, pixel_size.width() * 4,
                                               base::mac::GetSystemColorSpace(),
                                               kCGImageAlphaPremultipliedFirst |
                                                   kCGBitmapByteOrder32Host);
  DCHECK(context);

  return context;
}

}  // namespace content