DevTools: Implemented new properties of ScreencastFrameMetadata

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 <map>
 #include <string>
 
 #include "base/barrier_closure.h"
@@ skipping 185 matching lines @@
           kFrameRateThresholdMs) {
     return;
   }
 
   RenderViewHost* host = agent_->GetRenderViewHost();
   if (!host->GetView())
     return;
 
   last_frame_time_ = base::TimeTicks::Now();
 
-  RenderWidgetHostViewBase* view = static_cast<RenderWidgetHostViewBase*>(
-      host->GetView());
-  gfx::Size screen_size_dip(view->GetRequestedRendererSize());
+  // FIXME: do not use previous frame metadata.

[pfeldman, 2014/06/25 13:19:10]

// TODO(vkuzkokov): do not ...
as per chromium coding style

+  cc::CompositorFrameMetadata& metadata = last_compositor_frame_metadata_;
+
+  float page_scale = metadata.page_scale_factor;
+  gfx::SizeF view_size_dip = gfx::ScaleSize(metadata.viewport_size, page_scale);

[dgozman, 2014/06/25 13:25:38]

I'd say this is actually viewport_size_dip.

+
+  float total_bar_height = metadata.location_bar_content_translation.y() +

[dgozman, 2014/06/25 13:25:38]

total_bar_height_dip

+                               metadata.overdraw_bottom_height;
+  gfx::SizeF screen_size_dip(view_size_dip.width(),

[dgozman, 2014/06/25 13:25:38]

And this one is view_size_dip.

+                             view_size_dip.height() + total_bar_height);
 
   std::string format;
   int quality = kDefaultScreenshotQuality;
   double scale = 1;
   double max_width = -1;
   double max_height = -1;
   base::DictionaryValue* params = screencast_command_->params();
   if (params) {
     params->GetString(devtools::Page::startScreencast::kParamFormat,
                       &format);
     params->GetInteger(devtools::Page::startScreencast::kParamQuality,
                        &quality);
     params->GetDouble(devtools::Page::startScreencast::kParamMaxWidth,
                       &max_width);
     params->GetDouble(devtools::Page::startScreencast::kParamMaxHeight,
                       &max_height);
   }
 
+  RenderWidgetHostViewBase* view = static_cast<RenderWidgetHostViewBase*>(
+      host->GetView());
   blink::WebScreenInfo screen_info;
   view->GetScreenInfo(&screen_info);
   double device_scale_factor = screen_info.deviceScaleFactor;
 
   if (max_width > 0) {
     double max_width_dip = max_width / device_scale_factor;
     scale = std::min(scale, max_width_dip / screen_size_dip.width());
   }
   if (max_height > 0) {
     double max_height_dip = max_height / device_scale_factor;
     scale = std::min(scale, max_height_dip / screen_size_dip.height());
   }
 
   if (format.empty())
     format = kPng;
   if (quality < 0 || quality > 100)
     quality = kDefaultScreenshotQuality;
   if (scale <= 0)
     scale = 0.1;
 
-  // FIXME: do not use previous frame metadata.
-  cc::CompositorFrameMetadata& metadata = last_compositor_frame_metadata_;
-  gfx::SizeF view_size_dip = gfx::ScaleSize(metadata.viewport_size,
-                                            metadata.page_scale_factor);
-
   gfx::Size snapshot_size_dip(gfx::ToRoundedSize(
       gfx::ScaleSize(view_size_dip, scale)));
-
   if (snapshot_size_dip.width() > 0 && snapshot_size_dip.height() > 0) {
     gfx::Rect view_bounds_dip(gfx::ToRoundedSize(view_size_dip));
     view->CopyFromCompositingSurface(
         view_bounds_dip, snapshot_size_dip,
         base::Bind(&RendererOverridesHandler::ScreencastFrameCaptured,
                    weak_factory_.GetWeakPtr(),
                    format, quality, last_compositor_frame_metadata_),
         SkBitmap::kARGB_8888_Config);
   }
 }
@@ skipping 337 matching lines @@
                         metadata.root_scroll_offset.x());
     viewport->SetDouble(devtools::DOM::Rect::kParamY,
                         metadata.root_scroll_offset.y());
     viewport->SetDouble(devtools::DOM::Rect::kParamWidth,
                         metadata.viewport_size.width());
     viewport->SetDouble(devtools::DOM::Rect::kParamHeight,
                         metadata.viewport_size.height());
     response_metadata->Set(
         devtools::Page::ScreencastFrameMetadata::kParamViewport, viewport);
 
+    gfx::SizeF view_size_dip = gfx::ScaleSize(metadata.viewport_size,
+                                              metadata.page_scale_factor);
+    base::DictionaryValue* device = new base::DictionaryValue();
+    device->SetDouble(devtools::DOM::Rect::kParamWidth,
+                      view_size_dip.width());
+    device->SetDouble(devtools::DOM::Rect::kParamHeight,
+                      view_size_dip.height() +
+                          metadata.location_bar_content_translation.y() +
+                          metadata.overdraw_bottom_height);
+    response_metadata->Set(
+        devtools::Page::ScreencastFrameMetadata::kParamDevice, device);

[pfeldman, 2014/06/25 13:19:10]

This would require the roll, no? I'd rather have the above part fixed separately
(and sooner rather than later).

+
     response->Set(devtools::Page::screencastFrame::kParamMetadata,
                   response_metadata);
   }
 
   SendNotification(devtools::Page::screencastFrame::kName, response);
 }
 
 // Quota and Usage ------------------------------------------
 
 namespace {
@@ skipping 356 matching lines @@
       return NULL;
     }
     event.data.pinchUpdate.scale = static_cast<float>(scale);
   }
 
   host->ForwardGestureEvent(event);
   return command->SuccessResponse(NULL);
 }
 
 }  // namespace content