DevTools: optimize screencast for slower devices.

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 78 matching lines @@
 }  // namespace
 
 typedef DevToolsProtocolClient::Response Response;
 
 PageHandler::PageHandler()
     : enabled_(false),
       screencast_enabled_(false),
       screencast_quality_(kDefaultScreenshotQuality),
       screencast_max_width_(-1),
       screencast_max_height_(-1),
+      capture_every_nth_frame_(1),
       capture_retry_count_(0),
       has_compositor_frame_metadata_(false),
-      screencast_frame_sent_(0),
-      screencast_frame_acked_(0),
-      processing_screencast_frame_(false),
+      frame_counter_(0),
+      frames_in_flight_(0),
       color_picker_(new ColorPicker(base::Bind(
           &PageHandler::OnColorPicked, base::Unretained(this)))),
       host_(nullptr),
       weak_factory_(this) {
 }
 
 PageHandler::~PageHandler() {
 }
 
 void PageHandler::SetRenderFrameHost(RenderFrameHostImpl* host) {
@@ skipping 167 matching lines @@
   *result = true;
 #else
   *result = false;
 #endif  // defined(OS_ANDROID)
   return Response::OK();
 }
 
 Response PageHandler::StartScreencast(const std::string* format,
                                       const int* quality,
                                       const int* max_width,
-                                      const int* max_height) {
+                                      const int* max_height,
+                                      const int* every_nth_frame) {
   RenderWidgetHostImpl* widget_host =
       host_ ? host_->GetRenderWidgetHost() : nullptr;
   if (!widget_host)
     return Response::InternalError("Could not connect to view");
 
   screencast_enabled_ = true;
   screencast_format_ = format ? *format : kPng;
   screencast_quality_ = quality ? *quality : kDefaultScreenshotQuality;
   if (screencast_quality_ < 0 || screencast_quality_ > 100)
     screencast_quality_ = kDefaultScreenshotQuality;
   screencast_max_width_ = max_width ? *max_width : -1;
   screencast_max_height_ = max_height ? *max_height : -1;
+  frame_counter_ = 0;
+  frames_in_flight_ = 0;

[dgozman, 2015/11/21 02:03:23]

Let's pass session id around.

+  capture_every_nth_frame_ = every_nth_frame ? *every_nth_frame : 1;
 
   bool visible = !widget_host->is_hidden();
   NotifyScreencastVisibility(visible);
   if (visible) {
     if (has_compositor_frame_metadata_) {
       InnerSwapCompositorFrame();
     } else {
       widget_host->Send(
           new ViewMsg_ForceRedraw(widget_host->GetRoutingID(), 0));
     }
   }
   return Response::FallThrough();
 }
 
 Response PageHandler::StopScreencast() {
   screencast_enabled_ = false;
   return Response::FallThrough();
 }
 
-Response PageHandler::ScreencastFrameAck(int frame_number) {
-  screencast_frame_acked_ = frame_number;
+Response PageHandler::ScreencastFrameAck() {
+  --frames_in_flight_;
   return Response::OK();
 }
 
 Response PageHandler::HandleJavaScriptDialog(bool accept,
                                              const std::string* prompt_text) {
   base::string16 prompt_override;
   if (prompt_text)
     prompt_override = base::UTF8ToUTF16(*prompt_text);
 
   WebContentsImpl* web_contents = GetWebContents();
@@ skipping 30 matching lines @@
 }
 
 void PageHandler::NotifyScreencastVisibility(bool visible) {
   if (visible)
     capture_retry_count_ = kCaptureRetryLimit;
   client_->ScreencastVisibilityChanged(
       ScreencastVisibilityChangedParams::Create()->set_visible(visible));
 }
 
 void PageHandler::InnerSwapCompositorFrame() {
-  if (screencast_frame_sent_ - screencast_frame_acked_ >
-      kMaxScreencastFramesInFlight || processing_screencast_frame_) {
-    return;
-  }
-
   if (!host_ || !host_->GetView())
     return;
 
+  if (frames_in_flight_ > kMaxScreencastFramesInFlight)
+    return;
+
+  if (++frame_counter_ % capture_every_nth_frame_)
+    return;
+
+  frames_in_flight_++;

[dgozman, 2015/11/21 02:03:23]

Move this into last |if| in this function.

+
   RenderWidgetHostViewBase* view = static_cast<RenderWidgetHostViewBase*>(
       host_->GetView());
   // TODO(vkuzkokov): do not use previous frame metadata.
   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);
@@ skipping 12 matching lines @@
     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) {
-    processing_screencast_frame_ = true;
     gfx::Rect viewport_bounds_dip(gfx::ToRoundedSize(viewport_size_dip));
     view->CopyFromCompositingSurface(
         viewport_bounds_dip,
         snapshot_size_dip,
         base::Bind(&PageHandler::ScreencastFrameCaptured,
                    weak_factory_.GetWeakPtr(),
                    last_compositor_frame_metadata_),
         kN32_SkColorType);
   }
 }
 
 void PageHandler::ScreencastFrameCaptured(
     const cc::CompositorFrameMetadata& metadata,
     const SkBitmap& bitmap,
     ReadbackResponse response) {
   if (response != READBACK_SUCCESS) {
-    processing_screencast_frame_ = false;
     if (capture_retry_count_) {
       --capture_retry_count_;
       base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
           FROM_HERE, base::Bind(&PageHandler::InnerSwapCompositorFrame,
                                 weak_factory_.GetWeakPtr()),
           base::TimeDelta::FromMilliseconds(kFrameRetryDelayMs));
     }
+    --frames_in_flight_;
     return;
   }
   base::PostTaskAndReplyWithResult(
       base::WorkerPool::GetTaskRunner(true).get(),
       FROM_HERE,
       base::Bind(&EncodeScreencastFrame,
                  bitmap, screencast_format_, screencast_quality_),
       base::Bind(&PageHandler::ScreencastFrameEncoded,
                  weak_factory_.GetWeakPtr(), metadata, base::Time::Now()));
 }
 
 void PageHandler::ScreencastFrameEncoded(
     const cc::CompositorFrameMetadata& metadata,
     const base::Time& timestamp,
     const std::string& data) {
-  processing_screencast_frame_ = false;
-
   // Consider metadata empty in case it has no device scale factor.
-  if (metadata.device_scale_factor == 0 || !host_ || data.empty())
+  if (metadata.device_scale_factor == 0 || !host_ || data.empty()) {
+    --frames_in_flight_;
     return;
+  }
 
   RenderWidgetHostViewBase* view = static_cast<RenderWidgetHostViewBase*>(
       host_->GetView());
-  if (!view)
+  if (!view) {
+    --frames_in_flight_;
     return;
+  }
 
   gfx::SizeF screen_size_dip =
       gfx::ScaleSize(gfx::SizeF(view->GetPhysicalBackingSize()),
                      1 / metadata.device_scale_factor);
   scoped_refptr<ScreencastFrameMetadata> param_metadata =
       ScreencastFrameMetadata::Create()
           ->set_page_scale_factor(metadata.page_scale_factor)
           ->set_offset_top(metadata.location_bar_content_translation.y())
           ->set_device_width(screen_size_dip.width())
           ->set_device_height(screen_size_dip.height())
           ->set_scroll_offset_x(metadata.root_scroll_offset.x())
           ->set_scroll_offset_y(metadata.root_scroll_offset.y())
           ->set_timestamp(timestamp.ToDoubleT());
   client_->ScreencastFrame(ScreencastFrameParams::Create()
       ->set_data(data)
-      ->set_metadata(param_metadata)
-      ->set_frame_number(++screencast_frame_sent_));
+      ->set_metadata(param_metadata));
 }
 
 void PageHandler::ScreenshotCaptured(DevToolsCommandId command_id,
                                      const unsigned char* png_data,
                                      size_t png_size) {
   if (!png_data || !png_size) {
     client_->SendError(command_id,
                        Response::InternalError("Unable to capture screenshot"));
     return;
   }
 
   std::string base_64_data;
   base::Base64Encode(
       base::StringPiece(reinterpret_cast<const char*>(png_data), png_size),
       &base_64_data);
 
   client_->SendCaptureScreenshotResponse(command_id,
       CaptureScreenshotResponse::Create()->set_data(base_64_data));
 }
 
 void PageHandler::OnColorPicked(int r, int g, int b, int a) {
   scoped_refptr<dom::RGBA> color =
       dom::RGBA::Create()->set_r(r)->set_g(g)->set_b(b)->set_a(a);
   client_->ColorPicked(ColorPickedParams::Create()->set_color(color));
 }
 
 }  // namespace page
 }  // namespace devtools
 }  // namespace content