Consistent CopyFromSurface() API, consolidated to RWHV

content/browser/devtools/protocol/page_handler.cc

 // Copyright 2014 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/protocol/page_handler.h"
 
 #include <string>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 452 matching lines @@
 
   if (frames_in_flight_ > kMaxScreencastFramesInFlight)
     return;
 
   if (++frame_counter_ % capture_every_nth_frame_)
     return;
 
   RenderWidgetHostViewBase* view = static_cast<RenderWidgetHostViewBase*>(
       host_->GetView());
   // TODO(vkuzkokov): do not use previous frame metadata.
+  // TODO(miu): RWHV to provide an API to provide actual rendering size.

[dgozman, 2017/02/28 19:13:52]

I think that would help in devtools_frame_trace_recorder as well.

Ideally, the clients would not have to do all the calculations. For example, 30
lines here try to express "copy everything but scale to not larger than |size|".

[miu, 2017/03/01 01:17:02]

Acknowledged.

+  // http://crbug.com/73362
   cc::CompositorFrameMetadata& metadata = last_compositor_frame_metadata_;
 
   gfx::SizeF viewport_size_dip = gfx::ScaleSize(
       metadata.scrollable_viewport_size, metadata.page_scale_factor);
   gfx::SizeF screen_size_dip =
       gfx::ScaleSize(gfx::SizeF(view->GetPhysicalBackingSize()),
                      1 / metadata.device_scale_factor);
 
   content::ScreenInfo screen_info;
   GetWebContents()->GetView()->GetScreenInfo(&screen_info);
   double device_scale_factor = screen_info.device_scale_factor;
   double scale = 1;
 
   if (screencast_max_width_ > 0) {
     double max_width_dip = screencast_max_width_ / device_scale_factor;
     scale = std::min(scale, max_width_dip / screen_size_dip.width());
   }
   if (screencast_max_height_ > 0) {
     double max_height_dip = screencast_max_height_ / device_scale_factor;
     scale = std::min(scale, max_height_dip / screen_size_dip.height());
   }
 
   if (scale <= 0)
     scale = 0.1;
 
   gfx::Size snapshot_size_dip(gfx::ToRoundedSize(
       gfx::ScaleSize(viewport_size_dip, scale)));
 
   if (snapshot_size_dip.width() > 0 && snapshot_size_dip.height() > 0) {
-    gfx::Rect viewport_bounds_dip(gfx::ToRoundedSize(viewport_size_dip));
-    view->CopyFromCompositingSurface(
-        viewport_bounds_dip, snapshot_size_dip,
+    view->CopyFromSurface(
+        gfx::Rect(), snapshot_size_dip,
         base::Bind(&PageHandler::ScreencastFrameCaptured,
                    weak_factory_.GetWeakPtr(),
                    base::Passed(last_compositor_frame_metadata_.Clone())),
         kN32_SkColorType);
     frames_in_flight_++;
   }
 }
 
 void PageHandler::ScreencastFrameCaptured(cc::CompositorFrameMetadata metadata,
                                           const SkBitmap& bitmap,
@@ skipping 73 matching lines @@
 Response PageHandler::StopLoading() {
   WebContentsImpl* web_contents = GetWebContents();
   if (!web_contents)
     return Response::InternalError();
   web_contents->Stop();
   return Response::OK();
 }
 
 }  // namespace protocol
 }  // namespace content