extensions/browser/api/capture_web_contents_function.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "extensions/browser/api/capture_web_contents_function.h"
   6
   7 #include "base/base64.h"
   8 #include "base/strings/stringprintf.h"
   9 #include "content/public/browser/render_widget_host.h"
  10 #include "content/public/browser/render_widget_host_view.h"
  11 #include "content/public/browser/web_contents.h"
  12 #include "extensions/browser/extension_function.h"
  13 #include "extensions/common/constants.h"
  14 #include "ui/gfx/codec/jpeg_codec.h"
  15 #include "ui/gfx/codec/png_codec.h"
  16 #include "ui/gfx/display.h"
  17 #include "ui/gfx/geometry/size_conversions.h"
  18 #include "ui/gfx/screen.h"
  19
  20 using content::RenderWidgetHost;
  21 using content::RenderWidgetHostView;
  22 using content::WebContents;
  23
  24 namespace extensions {
  25
  26 using api::extension_types::ImageDetails;
  27
  28 bool CaptureWebContentsFunction::HasPermission() {
  29   return true;
  30 }
  31
  32 bool CaptureWebContentsFunction::RunAsync() {
  33   EXTENSION_FUNCTION_VALIDATE(args_);
  34
  35   context_id_ = extension_misc::kCurrentWindowId;
  36   args_->GetInteger(0, &context_id_);
  37
  38   scoped_ptr<ImageDetails> image_details;
  39   if (args_->GetSize() > 1) {
  40     base::Value* spec = NULL;
  41     EXTENSION_FUNCTION_VALIDATE(args_->Get(1, &spec) && spec);
  42     image_details = ImageDetails::FromValue(*spec);
  43   }
  44
  45   if (!IsScreenshotEnabled())
  46     return false;
  47
  48   WebContents* contents = GetWebContentsForID(context_id_);
  49   if (!contents)
  50     return false;
  51
  52   // The default format and quality setting used when encoding jpegs.
  53   const api::extension_types::ImageFormat kDefaultFormat =
  54       api::extension_types::IMAGE_FORMAT_JPEG;
  55   const int kDefaultQuality = 90;
  56
  57   image_format_ = kDefaultFormat;
  58   image_quality_ = kDefaultQuality;
  59
  60   if (image_details) {
  61     if (image_details->format != api::extension_types::IMAGE_FORMAT_NONE)
  62       image_format_ = image_details->format;
  63     if (image_details->quality.get())
  64       image_quality_ = *image_details->quality;
  65   }
  66
  67   // TODO(miu): Account for fullscreen render widget?  http://crbug.com/419878
  68   RenderWidgetHostView* const view = contents->GetRenderWidgetHostView();
  69   RenderWidgetHost* const host = view ? view->GetRenderWidgetHost() : nullptr;
  70   if (!view || !host) {
  71     OnCaptureFailure(FAILURE_REASON_VIEW_INVISIBLE);
  72     return false;
  73   }
  74
  75   // By default, the requested bitmap size is the view size in screen
  76   // coordinates.  However, if there's more pixel detail available on the
  77   // current system, increase the requested bitmap size to capture it all.
  78   const gfx::Size view_size = view->GetViewBounds().size();
  79   gfx::Size bitmap_size = view_size;
  80   const gfx::NativeView native_view = view->GetNativeView();
  81   gfx::Screen* const screen = gfx::Screen::GetScreenFor(native_view);
  82   const float scale =
  83       screen->GetDisplayNearestWindow(native_view).device_scale_factor();
  84   if (scale > 1.0f)
  85     bitmap_size = gfx::ToCeiledSize(gfx::ScaleSize(view_size, scale));
  86
  87   host->CopyFromBackingStore(
  88       gfx::Rect(view_size),
  89       bitmap_size,
  90       base::Bind(&CaptureWebContentsFunction::CopyFromBackingStoreComplete,
  91                  this),
  92       kN32_SkColorType);
  93   return true;
  94 }
  95
  96 void CaptureWebContentsFunction::CopyFromBackingStoreComplete(
  97     const SkBitmap& bitmap,
  98     content::ReadbackResponse response) {
  99   if (response == content::READBACK_SUCCESS) {
 100     OnCaptureSuccess(bitmap);
 101     return;
 102   }
 103   OnCaptureFailure(FAILURE_REASON_UNKNOWN);
 104 }
 105
 106 void CaptureWebContentsFunction::OnCaptureSuccess(const SkBitmap& bitmap) {
 107   std::vector<unsigned char> data;
 108   SkAutoLockPixels screen_capture_lock(bitmap);
 109   bool encoded = false;
 110   std::string mime_type;
 111   switch (image_format_) {
 112     case api::extension_types::IMAGE_FORMAT_JPEG:
 113       encoded = gfx::JPEGCodec::Encode(
 114           reinterpret_cast<unsigned char*>(bitmap.getAddr32(0, 0)),
 115           gfx::JPEGCodec::FORMAT_SkBitmap,
 116           bitmap.width(),
 117           bitmap.height(),
 118           static_cast<int>(bitmap.rowBytes()),
 119           image_quality_,
 120           &data);
 121       mime_type = kMimeTypeJpeg;
 122       break;
 123     case api::extension_types::IMAGE_FORMAT_PNG:
 124       encoded =
 125           gfx::PNGCodec::EncodeBGRASkBitmap(bitmap,
 126                                             true,  // Discard transparency.
 127                                             &data);
 128       mime_type = kMimeTypePng;
 129       break;
 130     default:
 131       NOTREACHED() << "Invalid image format.";
 132   }
 133
 134   if (!encoded) {
 135     OnCaptureFailure(FAILURE_REASON_ENCODING_FAILED);
 136     return;
 137   }
 138
 139   std::string base64_result;
 140   base::StringPiece stream_as_string(
 141       reinterpret_cast<const char*>(vector_as_array(&data)), data.size());
 142
 143   base::Base64Encode(stream_as_string, &base64_result);
 144   base64_result.insert(
 145       0, base::StringPrintf("data:%s;base64,", mime_type.c_str()));
 146   SetResult(new base::StringValue(base64_result));
 147   SendResponse(true);
 148 }
 149
 150 }  // namespace extensions