[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 267 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;
   }
 
+  ui::SnapshotEncoding snapshot_encoding = format.fromMaybe(kPng) == kPng
+                                               ? ui::SnapshotEncoding::PNG
+                                               : ui::SnapshotEncoding::JPEG;
+  ui::SnapshotQuality snapshot_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))),
+      snapshot_encoding, snapshot_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 246 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 unsigned char* image_data,
+    size_t data_size) {
+  if (!image_data || !data_size) {
     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::StringPiece(reinterpret_cast<const char*>(image_data), data_size),
       &base_64_data);
   callback->sendSuccess(base_64_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