Add fromSurface optional parameter to devtools Page.CaptureScreenshot

content/browser/devtools/protocol/page_handler.cc

 // 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.
 
 #include "content/browser/devtools/protocol/page_handler.h"
 
+#include <algorithm>
+#include <memory>
 #include <string>
+#include <utility>
+#include <vector>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task_scheduler/post_task.h"
@@ skipping 16 matching lines @@
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/referrer.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/page_transition_types.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_util.h"
+#include "ui/gfx/switches.h"
 #include "ui/snapshot/snapshot.h"
 #include "url/gurl.h"
 
 namespace content {
 namespace protocol {
 
 namespace {
 
 static const char kPng[] = "png";
 static const char kJpeg[] = "jpeg";
@@ skipping 21 matching lines @@
 
   std::string base_64_data;
   base::Base64Encode(
       base::StringPiece(reinterpret_cast<const char*>(data->front()),
                         data->size()),
       &base_64_data);
 
   return base_64_data;
 }
 
+std::string EncodeBitmap(const SkBitmap& bitmap,

[Eric Seckler, 2017/03/06 07:32:53]

Don't think you need this specialized version of EncodeImage. You can do what
ScreencastFrameCaptured does:

base::Bind(&EncodeImage, gfx::Image::CreateFrom1xBitmap(bitmap), format,
quality)

[dvallet, 2017/03/08 02:26:14]

Done, thanks for the tip!

+                         const std::string& format,
+                         int quality) {
+  std::vector<unsigned char> data;
+  SkAutoLockPixels lock_image(bitmap);
+  bool encoded;
+  if (format == kPng) {
+    encoded = gfx::PNGCodec::Encode(
+        reinterpret_cast<unsigned char*>(bitmap.getAddr32(0, 0)),
+        gfx::PNGCodec::FORMAT_SkBitmap,
+        gfx::Size(bitmap.width(), bitmap.height()),
+        bitmap.width() * bitmap.bytesPerPixel(), false,
+        std::vector<gfx::PNGCodec::Comment>(), &data);
+  } else if (format == kJpeg) {
+    encoded = gfx::JPEGCodec::Encode(
+        reinterpret_cast<unsigned char*>(bitmap.getAddr32(0, 0)),
+        gfx::JPEGCodec::FORMAT_SkBitmap, bitmap.width(), bitmap.height(),
+        bitmap.width() * bitmap.bytesPerPixel(), quality, &data);
+  } else {
+    encoded = false;
+  }
+  if (!encoded)
+    return std::string();
+  std::string base_64_data;
+  base::Base64Encode(
+      base::StringPiece(reinterpret_cast<char*>(&data[0]), data.size()),
+      &base_64_data);
+  return base_64_data;
+}
+
 }  // namespace
 
 PageHandler::PageHandler()
     : DevToolsDomainHandler(Page::Metainfo::domainName),
       enabled_(false),
       screencast_enabled_(false),
       screencast_quality_(kDefaultScreenshotQuality),
       screencast_max_width_(-1),
       screencast_max_height_(-1),
       capture_every_nth_frame_(1),
@@ skipping 190 matching lines @@
     Maybe<std::string> format,
     Maybe<int> quality,
     std::unique_ptr<CaptureScreenshotCallback> callback) {
   if (!host_ || !host_->GetRenderWidgetHost()) {
     callback->sendFailure(Response::InternalError());
     return;
   }
 
   std::string screenshot_format = format.fromMaybe(kPng);
   int screenshot_quality = quality.fromMaybe(kDefaultScreenshotQuality);
-
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(switches::kHeadless)) {
+    host_->GetRenderWidgetHost()->GetBitmapSnapshotFromBrowser(base::Bind(
+        &PageHandler::BitmapScreenshotCaptured, weak_factory_.GetWeakPtr(),
+        base::Passed(std::move(callback)), screenshot_format,
+        screenshot_quality));
+    return;
+  }
   host_->GetRenderWidgetHost()->GetSnapshotFromBrowser(
       base::Bind(&PageHandler::ScreenshotCaptured, weak_factory_.GetWeakPtr(),
                  base::Passed(std::move(callback)), screenshot_format,
                  screenshot_quality));
 }
 
 void PageHandler::PrintToPDF(std::unique_ptr<PrintToPDFCallback> callback) {
   callback->sendFailure(Response::Error("PrintToPDF is not implemented"));
   return;
 }
@@ skipping 268 matching lines @@
     int quality,
     const gfx::Image& image) {
   if (image.IsEmpty()) {
     callback->sendFailure(Response::Error("Unable to capture screenshot"));
     return;
   }
 
   callback->sendSuccess(EncodeImage(image, format, quality));
 }
 
+void PageHandler::BitmapScreenshotCaptured(
+    std::unique_ptr<CaptureScreenshotCallback> callback,
+    const std::string& format,
+    int quality,
+    const SkBitmap& bitmap) {
+  if (bitmap.drawsNothing()) {
+    callback->sendFailure(Response::Error("Unable to capture screenshot"));
+    return;
+  }
+
+  base::PostTaskAndReplyWithResult(
+      FROM_HERE, base::Bind(&EncodeBitmap, bitmap, format, quality),
+      base::Bind(&PageHandler::BitmapScreenshotEncoded,
+                 weak_factory_.GetWeakPtr(),
+                 base::Passed(std::move(callback))));
+}
+
+void PageHandler::BitmapScreenshotEncoded(
+    std::unique_ptr<CaptureScreenshotCallback> callback,
+    const std::string& data) {
+  callback->sendSuccess(data);
+}
+
 void PageHandler::OnColorPicked(int r, int g, int b, int a) {
   frontend_->ColorPicked(
       DOM::RGBA::Create().SetR(r).SetG(g).SetB(b).SetA(a).Build());
 }
 
 Response PageHandler::StopLoading() {
   WebContentsImpl* web_contents = GetWebContents();
   if (!web_contents)
     return Response::InternalError();
   web_contents->Stop();
   return Response::OK();
 }
 
 }  // namespace protocol
 }  // namespace content