[devtools] Support different encodings for 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 <string>
 
 #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"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/browser/devtools/devtools_session.h"
 #include "content/browser/devtools/page_navigation_throttle.h"
 #include "content/browser/devtools/protocol/color_picker.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/browser/web_contents/web_contents_view.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/javascript_dialog_manager.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #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/snapshot/snapshot.h"
 #include "url/gurl.h"
 
 namespace content {
 namespace protocol {
 
 namespace {
 
 static const char kPng[] = "png";
 static const char kJpeg[] = "jpeg";
 static int kDefaultScreenshotQuality = 80;
 static int kFrameRetryDelayMs = 100;
 static int kCaptureRetryLimit = 2;
 static int kMaxScreencastFramesInFlight = 2;
 
-std::string EncodeScreencastFrame(const SkBitmap& bitmap,
-                                  const std::string& format,
-                                  int quality) {
-  std::vector<unsigned char> data;
-  SkAutoLockPixels lock_image(bitmap);
-  bool encoded;
+std::string EncodeImage(const gfx::Image& image,
+                        const std::string& format,
+                        int quality) {
+  DCHECK(!image.IsEmpty());
+
+  scoped_refptr<base::RefCountedMemory> data;
   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);
+    data = image.As1xPNGBytes();
   } 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;
+    scoped_refptr<base::RefCountedBytes> bytes(new base::RefCountedBytes());
+    if (gfx::JPEG1xEncodedDataFromImage(image, quality, &bytes->data()))
+      data = bytes;
   }
 
-  if (!encoded)
+  if (!data || !data->front())
     return std::string();
 
   std::string base_64_data;
   base::Base64Encode(
-      base::StringPiece(reinterpret_cast<char*>(&data[0]), data.size()),
+      base::StringPiece(reinterpret_cast<const char*>(data->front()),
+                        data->size()),
       &base_64_data);
 
   return base_64_data;
 }
 
 }  // namespace
 
 PageHandler::PageHandler()
     : DevToolsDomainHandler(Page::Metainfo::domainName),
       enabled_(false),
@@ skipping 182 matching lines @@
     if (controller.GetEntryAtIndex(i)->GetUniqueID() == entry_id) {
       controller.GoToIndex(i);
       return Response::OK();
     }
   }
 
   return Response::InvalidParams("No entry with passed id");
 }
 
 void PageHandler::CaptureScreenshot(
+    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);
+
   host_->GetRenderWidgetHost()->GetSnapshotFromBrowser(
-      base::Bind(&PageHandler::ScreenshotCaptured,
-          weak_factory_.GetWeakPtr(), base::Passed(std::move(callback))));
+      base::Bind(&PageHandler::ScreenshotCaptured, weak_factory_.GetWeakPtr(),
+                 base::Passed(std::move(callback)), screenshot_format,
+                 screenshot_quality));
 }
 
 Response PageHandler::StartScreencast(Maybe<std::string> format,
                                       Maybe<int> quality,
                                       Maybe<int> max_width,
                                       Maybe<int> max_height,
                                       Maybe<int> every_nth_frame) {
   RenderWidgetHostImpl* widget_host =
       host_ ? host_->GetRenderWidgetHost() : nullptr;
   if (!widget_host)
@@ skipping 205 matching lines @@
           FROM_HERE, base::Bind(&PageHandler::InnerSwapCompositorFrame,
                                 weak_factory_.GetWeakPtr()),
           base::TimeDelta::FromMilliseconds(kFrameRetryDelayMs));
     }
     --frames_in_flight_;
     return;
   }
   base::PostTaskWithTraitsAndReplyWithResult(
       FROM_HERE, base::TaskTraits().WithShutdownBehavior(
                      base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),
-      base::Bind(&EncodeScreencastFrame, bitmap, screencast_format_,
-                 screencast_quality_),
+      base::Bind(&EncodeImage, gfx::Image::CreateFrom1xBitmap(bitmap),
+                 screencast_format_, screencast_quality_),
       base::Bind(&PageHandler::ScreencastFrameEncoded,
                  weak_factory_.GetWeakPtr(), base::Passed(&metadata),
                  base::Time::Now()));
 }
 
 void PageHandler::ScreencastFrameEncoded(cc::CompositorFrameMetadata metadata,
                                          const base::Time& timestamp,
                                          const std::string& data) {
   // Consider metadata empty in case it has no device scale factor.
   if (metadata.device_scale_factor == 0 || !host_ || data.empty()) {
@@ skipping 20 matching lines @@
           .SetDeviceHeight(screen_size_dip.height())
           .SetScrollOffsetX(metadata.root_scroll_offset.x())
           .SetScrollOffsetY(metadata.root_scroll_offset.y())
           .SetTimestamp(timestamp.ToDoubleT())
           .Build();
   frontend_->ScreencastFrame(data, std::move(param_metadata), session_id_);
 }
 
 void PageHandler::ScreenshotCaptured(
     std::unique_ptr<CaptureScreenshotCallback> callback,
-    const unsigned char* png_data,
-    size_t png_size) {
-  if (!png_data || !png_size) {
+    const std::string& format,
+    int quality,
+    const gfx::Image& image) {
+  if (image.IsEmpty()) {
     callback->sendFailure(Response::Error("Unable to capture screenshot"));
     return;
   }
 
-  std::string base_64_data;
-  base::Base64Encode(
-      base::StringPiece(reinterpret_cast<const char*>(png_data), png_size),
-      &base_64_data);
-  callback->sendSuccess(base_64_data);
+  base::PostTaskWithTraitsAndReplyWithResult(

[pfeldman, 2017/01/07 01:13:27]

Why is this necessary? Weren't we doing it synchronously? It might be important
for screencast to encode async, but with capture screenshot it is less important
whether you do it in this task or another.

[Eric Seckler, 2017/01/09 14:52:04]

Great, making it synchronous :) Previously, it was half-half (png encoding
wasn't).

+      FROM_HERE, base::TaskTraits().WithShutdownBehavior(
+                     base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN),
+      base::Bind(&EncodeImage, image, format, quality),
+      base::Bind(&PageHandler::ScreenshotEncoded, weak_factory_.GetWeakPtr(),
+                 base::Passed(std::move(callback))));
+}
+
+void PageHandler::ScreenshotEncoded(
+    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