[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"
@@ skipping 33 matching lines @@
 
 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::string EncodeBitmap(const SkBitmap& bitmap,
+                         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);
@@ skipping 203 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 204 matching lines @@
       base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
           FROM_HERE, base::Bind(&PageHandler::InnerSwapCompositorFrame,
                                 weak_factory_.GetWeakPtr()),
           base::TimeDelta::FromMilliseconds(kFrameRetryDelayMs));
     }
     --frames_in_flight_;
     return;
   }
   base::PostTaskAndReplyWithResult(
       base::WorkerPool::GetTaskRunner(true).get(), FROM_HERE,
-      base::Bind(&EncodeScreencastFrame, bitmap, screencast_format_,
+      base::Bind(&EncodeBitmap, 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.
@@ skipping 21 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 SkBitmap& bitmap) {
+  if (bitmap.drawsNothing()) {
     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::PostTaskAndReplyWithResult(
+      base::WorkerPool::GetTaskRunner(true).get(), FROM_HERE,
+      base::Bind(&EncodeBitmap, bitmap, 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