DevTools: migrate from scale to max size parameters in capture screen.

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"
@@ skipping 32 matching lines @@
 using WebKit::WebInputEvent;
 using WebKit::WebMouseEvent;
 
 namespace content {
 
 namespace {
 
 static const char kPng[] = "png";
 static const char kJpeg[] = "jpeg";
 static int kDefaultScreenshotQuality = 80;
-
-void ParseCaptureParameters(DevToolsProtocol::Command* command,
-                            std::string* format,
-                            int* quality,
-                            double* scale) {
-  *quality = kDefaultScreenshotQuality;
-  *scale = 1;
-  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 = kPng;
-  if (*quality < 0 || *quality > 100)
-    *quality = kDefaultScreenshotQuality;
-  if (*scale <= 0 || *scale > 1)
-    *scale = 1;
-}
+static int kFrameRateThresholdMs = 100;
 
 void ParseGenericInputParams(base::DictionaryValue* params,
                              WebInputEvent* event) {
   int modifiers = 0;
   if (params->GetInteger(devtools::Input::kParamModifiers,
                          &modifiers)) {
     if (modifiers & 1)
       event->modifiers |= WebInputEvent::AltKey;
     if (modifiers & 2)
       event->modifiers |= WebInputEvent::ControlKey;
@@ skipping 69 matching lines @@
   ViewHostMsg_SwapCompositorFrame::Param param;
   if (!ViewHostMsg_SwapCompositorFrame::Read(&message, &param))
     return;
   last_compositor_frame_metadata_ = param.b.metadata;
 
   if (screencast_command_)
     InnerSwapCompositorFrame();
 }
 
 void RendererOverridesHandler::InnerSwapCompositorFrame() {
+  if ((base::TimeTicks::Now() - last_frame_time_).InMilliseconds() <
+          kFrameRateThresholdMs) {
+    return;
+  }
+
+  last_frame_time_ = base::TimeTicks::Now();
   std::string format;
   int quality = kDefaultScreenshotQuality;
   double scale = 1;
   ParseCaptureParameters(screencast_command_.get(), &format, &quality, &scale);
 
   RenderViewHost* host = agent_->GetRenderViewHost();
   RenderWidgetHostViewPort* view_port =
       RenderWidgetHostViewPort::FromRWHV(host->GetView());
 
   gfx::Rect view_bounds = host->GetView()->GetViewBounds();
   gfx::Size snapshot_size = gfx::ToFlooredSize(
       gfx::ScaleSize(view_bounds.size(), scale));
 
   view_port->CopyFromCompositingSurface(
       view_bounds, snapshot_size,
       base::Bind(&RendererOverridesHandler::ScreenshotCaptured,
                  weak_factory_.GetWeakPtr(),
                  scoped_refptr<DevToolsProtocol::Command>(), format, quality,
                  last_compositor_frame_metadata_));
 }
 
+void RendererOverridesHandler::ParseCaptureParameters(
+    DevToolsProtocol::Command* command,
+    std::string* format,
+    int* quality,
+    double* scale) {
+  RenderViewHost* host = agent_->GetRenderViewHost();
+  gfx::Rect view_bounds = host->GetView()->GetViewBounds();
+
+  *quality = kDefaultScreenshotQuality;
+  *scale = 1;
+  double max_width = -1;
+  double max_height = -1;
+  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::kParamMaxWidth,
+                      &max_width);
+    params->GetDouble(devtools::Page::captureScreenshot::kParamMaxHeight,
+                      &max_height);
+  }
+
+  float device_sf = last_compositor_frame_metadata_.device_scale_factor;
+
+  if (max_width > 0)
+    *scale = std::min(*scale, max_width / view_bounds.width() / device_sf);
+  if (max_height > 0)
+    *scale = std::min(*scale, max_height / view_bounds.height() / device_sf);
+
+  if (format->empty())
+    *format = kPng;
+  if (*quality < 0 || *quality > 100)
+    *quality = kDefaultScreenshotQuality;
+  if (*scale <= 0)
+    *scale = 0.1;
+  if (*scale > 5)
+    *scale = 5;
+}
 
 // DOM agent handlers  --------------------------------------------------------
 
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::GrantPermissionsForSetFileInputFiles(
     scoped_refptr<DevToolsProtocol::Command> command) {
   base::DictionaryValue* params = command->params();
   base::ListValue* file_list = NULL;
   const char* param =
       devtools::DOM::setFileInputFiles::kParamFiles;
@@ skipping 127 matching lines @@
 RendererOverridesHandler::PageStartScreencast(
     scoped_refptr<DevToolsProtocol::Command> command) {
   screencast_command_ = command;
   InnerSwapCompositorFrame();
   return command->SuccessResponse(NULL);
 }
 
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::PageStopScreencast(
     scoped_refptr<DevToolsProtocol::Command> command) {
+  last_frame_time_ = base::TimeTicks();
   screencast_command_ = NULL;
   return command->SuccessResponse(NULL);
 }
 
 void RendererOverridesHandler::ScreenshotCaptured(
     scoped_refptr<DevToolsProtocol::Command> command,
     const std::string& format,
     int quality,
     const cc::CompositorFrameMetadata& metadata,
     bool success,
@@ skipping 103 matching lines @@
     else if (type == "mouseReleased")
       mouse_event.type = WebInputEvent::MouseUp;
     else if (type == "mouseMoved")
       mouse_event.type = WebInputEvent::MouseMove;
     else
       return NULL;
   } else {
     return NULL;
   }
 
-  int x;
-  int y;
-  if (!params->GetInteger(devtools::kParamX, &x) ||
-      !params->GetInteger(devtools::kParamY, &y)) {
+  if (!params->GetInteger(devtools::kParamX, &mouse_event.x) ||
+      !params->GetInteger(devtools::kParamY, &mouse_event.y)) {
     return NULL;
   }
 
-  float device_scale_factor = ui::GetScaleFactorScale(
-      GetScaleFactorForView(host->GetView()));
-  mouse_event.x = floor(x / device_scale_factor);
-  mouse_event.y = floor(y / device_scale_factor);
   mouse_event.windowX = mouse_event.x;
   mouse_event.windowY = mouse_event.y;
   mouse_event.globalX = mouse_event.x;
   mouse_event.globalY = mouse_event.y;
 
   params->GetInteger(devtools::Input::dispatchMouseEvent::kParamClickCount,
                      &mouse_event.clickCount);
 
   std::string button;
   if (!params->GetString(devtools::Input::dispatchMouseEvent::kParamButton,
@@ skipping 50 matching lines @@
     else if (type == "pinchUpdate")
       event.type = WebInputEvent::GesturePinchUpdate;
     else if (type == "pinchEnd")
       event.type = WebInputEvent::GesturePinchEnd;
     else
       return NULL;
   } else {
     return NULL;
   }
 
-  float device_scale_factor = ui::GetScaleFactorScale(
-      GetScaleFactorForView(host->GetView()));
-
-  int x;
-  int y;
-  if (!params->GetInteger(devtools::kParamX, &x) ||
-      !params->GetInteger(devtools::kParamY, &y)) {
+  if (!params->GetInteger(devtools::kParamX, &event.x) ||
+      !params->GetInteger(devtools::kParamY, &event.y)) {
     return NULL;
   }
-  event.x = floor(x / device_scale_factor);
-  event.y = floor(y / device_scale_factor);
   event.globalX = event.x;
   event.globalY = event.y;
 
   if (type == "scrollUpdate") {
     int dx;
     int dy;
     if (!params->GetInteger(
             devtools::Input::dispatchGestureEvent::kParamDeltaX, &dx) ||
         !params->GetInteger(
             devtools::Input::dispatchGestureEvent::kParamDeltaY, &dy)) {
       return NULL;
     }
-    event.data.scrollUpdate.deltaX = floor(dx / device_scale_factor);
-    event.data.scrollUpdate.deltaY = floor(dy / device_scale_factor);
+    event.data.scrollUpdate.deltaX = dx;
+    event.data.scrollUpdate.deltaY = dy;
   }
 
   if (type == "pinchUpdate") {
     double scale;
     if (!params->GetDouble(
         devtools::Input::dispatchGestureEvent::kParamPinchScale,
         &scale)) {
       return NULL;
     }
     event.data.pinchUpdate.scale = static_cast<float>(scale);
   }
 
   host->ForwardGestureEvent(event);
   return command->SuccessResponse(NULL);
 }
 
 }  // namespace content