DevTools: expose last composited frame metadata on RenderWidgetHostViewPort.

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/values.h"
+#include "cc/output/compositor_frame_metadata.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/dip_util.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
+#include "content/common/view_messages.h"
 #include "content/port/browser/render_widget_host_view_port.h"
 #include "content/public/browser/browser_thread.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 "ipc/ipc_sender.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/snapshot/snapshot.h"
 #include "url/gurl.h"
 
 using WebKit::WebGestureEvent;
 using WebKit::WebInputEvent;
 using WebKit::WebMouseEvent;
@@ skipping 98 matching lines @@
           &RendererOverridesHandler::InputDispatchGestureEvent,
           base::Unretained(this)));
 }
 
 RendererOverridesHandler::~RendererOverridesHandler() {}
 
 void RendererOverridesHandler::OnClientDetached() {
   screencast_command_ = NULL;
 }
 
-void RendererOverridesHandler::OnSwapCompositorFrame() {
+void RendererOverridesHandler::OnSwapCompositorFrame(

[no sievers, 2013/08/29 20:24:52]

Can you even save the metadata in here instead of putting it into RWHVBase?

+    const IPC::Message& message) {
   if (!screencast_command_)
     return;
 
+  ViewHostMsg_SwapCompositorFrame::Param param;
+  if (!ViewHostMsg_SwapCompositorFrame::Read(&message, &param))
+    return;
+  scoped_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
+  param.b.AssignTo(frame.get());
+  InnerSwapCompositorFrame(frame->metadata);
+}
+
+void RendererOverridesHandler::InnerSwapCompositorFrame(
+    const cc::CompositorFrameMetadata& metadata) {
   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,
-                 scale));
+                 metadata));
 }
 
 
 // DOM agent handlers  --------------------------------------------------------
 
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::GrantPermissionsForSetFileInputFiles(
     scoped_refptr<DevToolsProtocol::Command> command) {
   base::DictionaryValue* params = command->params();
   base::ListValue* file_list = NULL;
@@ skipping 98 matching lines @@
   bool is_unscaled_png = scale == 1 && format == kPng;
   if (is_unscaled_png && ui::GrabViewSnapshot(host->GetView()->GetNativeView(),
                                               &png, view_bounds)) {
     std::string base64_data;
     bool success = base::Base64Encode(
         base::StringPiece(reinterpret_cast<char*>(&*png.begin()), png.size()),
         &base64_data);
     if (success) {
       base::DictionaryValue* result = new base::DictionaryValue();
       result->SetString(
-          devtools::Page::captureScreenshot::kResponseData, base64_data);
+          devtools::Page::kData, base64_data);
       return command->SuccessResponse(result);
     }
     return command->InternalErrorResponse("Unable to base64encode screenshot");
   }
 
   // Fallback to copying from compositing surface.
   RenderWidgetHostViewPort* view_port =
       RenderWidgetHostViewPort::FromRWHV(host->GetView());
 
   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(), command, format, quality, scale));
+                 weak_factory_.GetWeakPtr(), command, format, quality,
+                 view_port->GetLastCompositorFrameMetadata()));
   return command->AsyncResponsePromise();
 }
 
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::PageStartScreencast(
     scoped_refptr<DevToolsProtocol::Command> command) {
   screencast_command_ = command;
-  OnSwapCompositorFrame();
+
+  RenderViewHost* host = agent_->GetRenderViewHost();
+  RenderWidgetHostViewPort* view_port =
+      RenderWidgetHostViewPort::FromRWHV(host->GetView());
+
+  InnerSwapCompositorFrame(view_port->GetLastCompositorFrameMetadata());
   return command->SuccessResponse(NULL);
 }
 
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::PageStopScreencast(
     scoped_refptr<DevToolsProtocol::Command> command) {
   screencast_command_ = NULL;
   return command->SuccessResponse(NULL);
 }
 
 void RendererOverridesHandler::ScreenshotCaptured(
     scoped_refptr<DevToolsProtocol::Command> command,
     const std::string& format,
     int quality,
-    double scale,
+    const cc::CompositorFrameMetadata& metadata,
     bool success,
     const SkBitmap& bitmap) {
   if (!success) {
     if (command) {
       SendAsyncResponse(
           command->InternalErrorResponse("Unable to capture screenshot"));
     }
     return;
   }
 
@@ skipping 33 matching lines @@
                               data.size()),
                           &base_64_data)) {
     if (command) {
       SendAsyncResponse(
           command->InternalErrorResponse("Unable to base64 encode"));
     }
     return;
   }
 
   base::DictionaryValue* response = new base::DictionaryValue();
+  response->SetString(devtools::Page::kData, base_64_data);
+
+  // Consider metadata empty in case it has no device scale factor.
+  if (metadata.device_scale_factor != 0) {
+    response->SetDouble(devtools::Page::kParamDeviceScaleFactor,
+                        metadata.device_scale_factor);
+    response->SetDouble(devtools::Page::kParamPageScaleFactor,
+                        metadata.page_scale_factor);
+
+    base::DictionaryValue* viewport = new base::DictionaryValue();
+    viewport->SetDouble(devtools::kParamX, metadata.root_scroll_offset.x());
+    viewport->SetDouble(devtools::kParamY, metadata.root_scroll_offset.y());
+    viewport->SetDouble(devtools::kParamWidth, metadata.viewport_size.width());
+    viewport->SetDouble(devtools::kParamHeight,
+                        metadata.viewport_size.height());
+    response->Set(devtools::Page::kParamViewport, viewport);
+  }
+
   if (command) {
-    response->SetString(
-        devtools::Page::captureScreenshot::kResponseData, base_64_data);
     SendAsyncResponse(command->SuccessResponse(response));
   } else {
-    response->SetString(
-        devtools::Page::screencastFrame::kResponseData, base_64_data);
     SendNotification(devtools::Page::screencastFrame::kName, response);
   }
 }
 
 
 // Input agent handlers  ------------------------------------------------------
 
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::InputDispatchMouseEvent(
     scoped_refptr<DevToolsProtocol::Command> command) {
@@ skipping 22 matching lines @@
     else if (type == "mouseMoved")
       mouse_event.type = WebInputEvent::MouseMove;
     else
       return NULL;
   } else {
     return NULL;
   }
 
   int x;
   int y;
-  if (!params->GetInteger(devtools::Input::kParamX, &x) ||
-      !params->GetInteger(devtools::Input::kParamY, &y)) {
+  if (!params->GetInteger(devtools::kParamX, &x) ||
+      !params->GetInteger(devtools::kParamY, &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;
@@ skipping 62 matching lines @@
       return NULL;
   } else {
     return NULL;
   }
 
   float device_scale_factor = ui::GetScaleFactorScale(
       GetScaleFactorForView(host->GetView()));
 
   int x;
   int y;
-  if (!params->GetInteger(devtools::Input::kParamX, &x) ||
-      !params->GetInteger(devtools::Input::kParamY, &y)) {
+  if (!params->GetInteger(devtools::kParamX, &x) ||
+      !params->GetInteger(devtools::kParamY, &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;
@@ skipping 15 matching lines @@
       return NULL;
     }
     event.data.pinchUpdate.scale = static_cast<float>(scale);
   }
 
   host->ForwardGestureEvent(event);
   return command->SuccessResponse(NULL);
 }
 
 }  // namespace content