[devtools] Support different encodings for Page.CaptureScreenshot.

content/browser/renderer_host/render_widget_host_impl.cc

 // Copyright (c) 2012 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/renderer_host/render_widget_host_impl.h"
 
 #include <math.h>
 
 #include <set>
 #include <tuple>
@@ skipping 71 matching lines @@
 #include "third_party/WebKit/public/web/WebCompositionUnderline.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/events/blink/web_input_event_traits.h"
 #include "ui/events/event.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/gfx/color_space.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/skbitmap_operations.h"
-#include "ui/snapshot/snapshot.h"
 
 #if defined(OS_MACOSX)
 #include "device/power_save_blocker/power_save_blocker.h"
 #include "ui/accelerated_widget_mac/window_resize_helper_mac.h"
 #endif
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 using blink::WebDragOperation;
@@ skipping 164 matching lines @@
       text_direction_canceled_(false),
       suppress_events_until_keydown_(false),
       pending_mouse_lock_request_(false),
       allow_privileged_mouse_lock_(false),
       has_touch_handler_(false),
       is_in_touchpad_gesture_scroll_(false),
       is_in_touchscreen_gesture_scroll_(false),
       received_paint_after_load_(false),
       latency_tracker_(),
       next_browser_snapshot_id_(1),
+      pending_browser_snapshots_(0),
       owned_by_render_frame_host_(false),
       is_focused_(false),
       hung_renderer_delay_(
           base::TimeDelta::FromMilliseconds(kHungRendererDelayMs)),
       hang_monitor_reason_(
           RendererUnresponsiveType::RENDERER_UNRESPONSIVE_UNKNOWN),
       hang_monitor_event_type_(blink::WebInputEvent::Undefined),
       last_event_type_(blink::WebInputEvent::Undefined),
       new_content_rendering_delay_(
           base::TimeDelta::FromMilliseconds(kNewContentRenderingDelayMs)),
@@ skipping 1136 matching lines @@
   // factor).
   WasResized();
 
   if (touch_emulator_) {
     touch_emulator_->SetDeviceScaleFactor(
         view_.get() ? content::GetScaleFactorForView(view_.get()) : 1.0f);
   }
 }
 
 void RenderWidgetHostImpl::GetSnapshotFromBrowser(
-    const GetSnapshotFromBrowserCallback& callback) {
+    const GetSnapshotFromBrowserCallback& callback,
+    ui::SnapshotEncoding encoding,
+    ui::SnapshotQuality quality) {
   int id = next_browser_snapshot_id_++;
 
 #if defined(OS_MACOSX)
   // MacOS version of underlying GrabViewSnapshot() blocks while
   // display/GPU are in a power-saving mode, so make sure display
   // does not go to sleep for the duration of reading a snapshot.
-  if (pending_browser_snapshots_.empty()) {
+  if (pending_browser_snapshots_ == 0) {
     DCHECK(!power_save_blocker_);
     power_save_blocker_.reset(new device::PowerSaveBlocker(
         device::PowerSaveBlocker::kPowerSaveBlockPreventDisplaySleep,
         device::PowerSaveBlocker::kReasonOther, "GetSnapshot",
         BrowserThread::GetTaskRunnerForThread(BrowserThread::UI),
         BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE)));
   }
 #endif
-  pending_browser_snapshots_.insert(std::make_pair(id, callback));
+  pending_browser_snapshot_params_.insert(
+      std::make_pair(id, PendingSnapshotParams(callback, encoding, quality)));
+  pending_browser_snapshots_++;
   ui::LatencyInfo latency_info;
   latency_info.AddLatencyNumber(ui::WINDOW_SNAPSHOT_FRAME_NUMBER_COMPONENT, 0,
                                 id);
   Send(new ViewMsg_ForceRedraw(GetRoutingID(), latency_info));
 }
 
 const NativeWebKeyboardEvent*
     RenderWidgetHostImpl::GetLastKeyboardEvent() const {
   return input_router_->GetLastKeyboardEvent();
 }
@@ skipping 887 matching lines @@
 void RenderWidgetHostImpl::DidReceiveRendererFrame() {
   view_->DidReceiveRendererFrame();
 }
 
 void RenderWidgetHostImpl::WindowSnapshotReachedScreen(int snapshot_id) {
   DCHECK(base::MessageLoopForUI::IsCurrent());
 
   gfx::Rect view_bounds = GetView()->GetViewBounds();
   gfx::Rect snapshot_bounds(view_bounds.size());
 
-  std::vector<unsigned char> png;
-  if (ui::GrabViewSnapshot(
-      GetView()->GetNativeView(), &png, snapshot_bounds)) {
-    OnSnapshotDataReceived(snapshot_id, &png.front(), png.size());
-    return;
+  // Any pending snapshots with a lower ID than the one received are considered
+  // to be implicitly complete. Grab snapshots in requested encodings.
+  PendingSnapshotParamsMap::iterator it =
+      pending_browser_snapshot_params_.begin();
+  while (it != pending_browser_snapshot_params_.end()) {
+    if (it->first <= snapshot_id) {
+      std::vector<unsigned char> data;
+      if (ui::GrabViewSnapshot(GetView()->GetNativeView(), &data,

[pfeldman, 2017/01/03 18:42:33]

Why don't we grab it once and then encode here?

[Eric Seckler, 2017/01/03 19:18:09]

What would that look like? I moved the encoding into GrabViewSnapshot since it
is done differently depending on the platform. Would we instead always encode
into PNG in GrabViewSnapshot and then decode and reencode here for JPEG?

I considered the overhead of that de+reencode to be more significant compared to
the (probably unlikely) case that we have multiple screenshots in the queue for
the same frame - is that a bad assumption? :)

[pfeldman, 2017/01/04 00:10:50]

There is nothing wrong with your assumption, but capturing multiple times in a
loop, while knowing that the result will be the same isn't pretty. MacOS is the
only place you need to work around. I was hoping you could do something like
NSImageToSkBitmapWithColorSpace and operate on SkBitmap from there.

[Eric Seckler, 2017/01/06 21:06:01]

I've changed ui::Grab*Snapshot* methods to return gfx::Images that are either
backed by an NSImage (mac) or an SkBitmap (other platforms), and am converting
from either of these two representations in PageHandler, using existing /
extended helper methods. Does this make more sense?

+                               snapshot_bounds, it->second.encoding,
+                               it->second.quality)) {
+        OnSnapshotDataReceived(it->second.callback, &data.front(), data.size());
+      } else {
+        ui::GrabViewSnapshotAsync(
+            GetView()->GetNativeView(), snapshot_bounds,
+            base::ThreadTaskRunnerHandle::Get(),
+            base::Bind(&RenderWidgetHostImpl::OnSnapshotDataReceivedAsync,
+                       weak_factory_.GetWeakPtr(), it->second.callback),
+            it->second.encoding, it->second.quality);
+      }
+      pending_browser_snapshot_params_.erase(it++);
+    } else {
+      ++it;
+    }
   }
-
-  ui::GrabViewSnapshotAsync(
-      GetView()->GetNativeView(),
-      snapshot_bounds,
-      base::ThreadTaskRunnerHandle::Get(),
-      base::Bind(&RenderWidgetHostImpl::OnSnapshotDataReceivedAsync,
-                 weak_factory_.GetWeakPtr(),
-                 snapshot_id));
 }
 
-void RenderWidgetHostImpl::OnSnapshotDataReceived(int snapshot_id,
-                                                  const unsigned char* data,
-                                                  size_t size) {
-  // Any pending snapshots with a lower ID than the one received are considered
-  // to be implicitly complete, and returned the same snapshot data.
-  PendingSnapshotMap::iterator it = pending_browser_snapshots_.begin();
-  while (it != pending_browser_snapshots_.end()) {
-      if (it->first <= snapshot_id) {
-        it->second.Run(data, size);
-        pending_browser_snapshots_.erase(it++);
-      } else {
-        ++it;
-      }
-  }
+void RenderWidgetHostImpl::OnSnapshotDataReceived(
+    const GetSnapshotFromBrowserCallback& callback,
+    const unsigned char* data,
+    size_t size) {
+  DCHECK_LT(0, pending_browser_snapshots_);
+  callback.Run(data, size);
+  pending_browser_snapshots_--;
 #if defined(OS_MACOSX)
-  if (pending_browser_snapshots_.empty())
+  if (pending_browser_snapshots_ == 0)
     power_save_blocker_.reset();
 #endif
 }
 
 void RenderWidgetHostImpl::OnSnapshotDataReceivedAsync(
-    int snapshot_id,
+    const GetSnapshotFromBrowserCallback& callback,
     scoped_refptr<base::RefCountedBytes> png_data) {
   if (png_data.get())
-    OnSnapshotDataReceived(snapshot_id, png_data->front(), png_data->size());
+    OnSnapshotDataReceived(callback, png_data->front(), png_data->size());
   else
-    OnSnapshotDataReceived(snapshot_id, NULL, 0);
+    OnSnapshotDataReceived(callback, NULL, 0);
 }
 
 // static
 void RenderWidgetHostImpl::CompositorFrameDrawn(
     const std::vector<ui::LatencyInfo>& latency_info) {
   for (size_t i = 0; i < latency_info.size(); i++) {
     std::set<RenderWidgetHostImpl*> rwhi_set;
     for (const auto& lc : latency_info[i].latency_components()) {
       if (lc.first.first == ui::INPUT_EVENT_LATENCY_BEGIN_RWH_COMPONENT ||
           lc.first.first == ui::WINDOW_SNAPSHOT_FRAME_NUMBER_COMPONENT ||
@@ skipping 101 matching lines @@
     // Note: We are using the origin URL provided by the sender here. It may be
     // different from the receiver's.
     file_system_file.url =
         GURL(storage::GetIsolatedFileSystemRootURIString(
                  file_system_url.origin(), filesystem_id, std::string())
                  .append(register_name));
     file_system_file.filesystem_id = filesystem_id;
   }
 }
 
+RenderWidgetHostImpl::PendingSnapshotParams::PendingSnapshotParams(
+    const GetSnapshotFromBrowserCallback& callback,
+    ui::SnapshotEncoding encoding,
+    ui::SnapshotQuality quality)
+    : callback(callback), encoding(encoding), quality(quality) {}
+
+RenderWidgetHostImpl::PendingSnapshotParams::PendingSnapshotParams(
+    const PendingSnapshotParams& params) = default;
+
+RenderWidgetHostImpl::PendingSnapshotParams::~PendingSnapshotParams() = default;
+
 }  // namespace content