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/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"
@@ skipping 138 matching lines @@
 
   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));
+                 view_port->GetCompositorFrameMetadata()));
 }
 
 
 // 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->GetCompositorFrameMetadata()));

[Sami, 2013/08/28 15:42:50]

I think reading the screenshot and the frame metadata separately is going to be
too racy and lead to problems down the road. Let's take another shot at making
the compositor give back both pieces of data atomically. WDYT?

   return command->AsyncResponsePromise();
 }
 
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::PageStartScreencast(
     scoped_refptr<DevToolsProtocol::Command> command) {
   screencast_command_ = command;
   OnSwapCompositorFrame();
   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 32 matching lines @@
                               reinterpret_cast<char*>(&data[0]),
                               data.size()),
                           &base_64_data)) {
     if (command) {
       SendAsyncResponse(
           command->InternalErrorResponse("Unable to base64 encode"));
     }
     return;
   }
 
+  base::DictionaryValue* viewport = new base::DictionaryValue();
+  viewport->SetDouble(devtools::Page::kDeviceScaleFactor,
+                      metadata.device_scale_factor);
+  viewport->SetDouble(devtools::Page::kPageScaleFactor,
+                      metadata.page_scale_factor);
+  viewport->SetDouble(devtools::Page::kScrollLeft,
+                      metadata.root_scroll_offset.x());
+  viewport->SetDouble(devtools::Page::kScrollTop,
+                      metadata.root_scroll_offset.y());
+  viewport->SetDouble(devtools::Page::kViewportWidth,
+                      metadata.viewport_size.width());
+  viewport->SetDouble(devtools::Page::kViewportHeight,
+                      metadata.viewport_size.height());
+
   base::DictionaryValue* response = new base::DictionaryValue();
+  response->SetString(devtools::Page::kData, base_64_data);
+  response->Set(devtools::Page::kViewport, 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 143 matching lines @@
       return NULL;
     }
     event.data.pinchUpdate.scale = static_cast<float>(scale);
   }
 
   host->ForwardGestureEvent(event);
   return command->SuccessResponse(NULL);
 }
 
 }  // namespace content