DevTools: [Android] implement RenderWidgetHostViewAndroid::CopyFromCompositingSurface

content/browser/devtools/renderer_overrides_handler.cc

 // Copyright (c) 2013 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/renderer_overrides_handler.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/strings/string16.h"
+#include "base/time/time.h"
 #include "base/values.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/devtools/devtools_protocol_constants.h"
 #include "content/browser/devtools/devtools_tracing_handler.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
+#include "content/port/browser/render_view_host_delegate_view.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/javascript_dialog_manager.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/page_transition_types.h"
 #include "content/public/common/referrer.h"
-#include "ui/snapshot/snapshot.h"
 #include "url/gurl.h"
 
+using base::TimeTicks;
+
 namespace content {
 
 RendererOverridesHandler::RendererOverridesHandler(DevToolsAgentHost* agent)
     : agent_(agent) {
   RegisterCommandHandler(
       devtools::DOM::setFileInputFiles::kName,
       base::Bind(
           &RendererOverridesHandler::GrantPermissionsForSetFileInputFiles,
           base::Unretained(this)));
   RegisterCommandHandler(
@@ skipping 90 matching lines @@
           .LoadURL(gurl, Referrer(), PAGE_TRANSITION_TYPED, std::string());
       return command->SuccessResponse(new base::DictionaryValue());
     }
   }
   return command->InternalErrorResponse("No WebContents to navigate");
 }
 
 scoped_ptr<DevToolsProtocol::Response>
 RendererOverridesHandler::PageCaptureScreenshot(
     DevToolsProtocol::Command* command) {
+  std::string format;
+  int quality = 100;
+  double scale = 0;
+
+  base::DictionaryValue* params = command->params();
+  if (params) {
+    params->GetString(devtools::Page::captureScreenshot::kParamFormat,
+                      &format);
+    params->GetInteger(devtools::Page::captureScreenshot::kParamQuality,
+                       &quality);
+    params->GetDouble(devtools::Page::captureScreenshot::kParamScale,
+                      &scale);
+  }
+
+  if (format.empty())
+    format = "png";
+  if (quality < 0 || quality > 100)
+    quality = 100;
+  if (scale <= 0 || scale > 1)
+    scale = 1;
+
   std::string base_64_data;
-  if (!CaptureScreenshot(&base_64_data))
-    return command->InternalErrorResponse("Unable to capture a screenshot");
+  if (!CaptureScreenshot(format, quality, scale, &base_64_data))
+    return command->InternalErrorResponse(
+        "Unable to capture a screenshot or "
+        "image format is not supported by the target");
 
   base::DictionaryValue* response = new base::DictionaryValue();
   response->SetString(
       devtools::Page::captureScreenshot::kResponseData, base_64_data);
   return command->SuccessResponse(response);
 }
 
-bool RendererOverridesHandler::CaptureScreenshot(std::string* base_64_data) {
+bool RendererOverridesHandler::CaptureScreenshot(const std::string& format,
+                                                 int quality,
+                                                 double scale,
+                                                 std::string* base_64_data) {
   RenderViewHost* host = agent_->GetRenderViewHost();
   gfx::Rect view_bounds = host->GetView()->GetViewBounds();
   gfx::Rect snapshot_bounds(view_bounds.size());
   gfx::Size snapshot_size = snapshot_bounds.size();
-  std::vector<unsigned char> png;
-  if (!ui::GrabViewSnapshot(host->GetView()->GetNativeView(),
-                            &png,
-                            snapshot_bounds))
+  RenderViewHostDelegate* delegate = host->GetDelegate();
+  RenderViewHostDelegateView* view = delegate->GetDelegateView();
+
+  if (!view)
     return false;
 
-  return base::Base64Encode(base::StringPiece(
-                                reinterpret_cast<char*>(&*png.begin()),
-                                png.size()),
+  std::vector<uint8> data;
+  if (!view->GrabSnapshot(format, quality, scale, &data))
+    return false;
+
+  bool res =  base::Base64Encode(base::StringPiece(
+                                reinterpret_cast<char*>(&*data.begin()),
+                                data.size()),
                             base_64_data);
+  return res;
 }
 
 }  // namespace content