DevTools: backend part of the color picker (behind experiment).

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"
 #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/thread_task_runner_handle.h"
 #include "base/values.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/browser/renderer_host/render_widget_host_view_base.h"
+#include "content/browser/web_contents/web_contents_impl.h"
+#include "content/common/cursors/webcursor.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/javascript_dialog_manager.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/page_transition_types.h"
 #include "content/public/common/referrer.h"
 #include "ipc/ipc_sender.h"
 #include "net/base/net_util.h"
+#include "third_party/WebKit/public/platform/WebCursorInfo.h"
 #include "third_party/WebKit/public/platform/WebScreenInfo.h"
 #include "third_party/WebKit/public/web/WebInputEvent.h"
+#include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/screen.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/snapshot/snapshot.h"
 #include "url/gurl.h"
 #include "webkit/browser/quota/quota_manager.h"
 
 using blink::WebGestureEvent;
 using blink::WebInputEvent;
 using blink::WebMouseEvent;
 
 namespace content {
 
 namespace {
 
 static const char kPng[] = "png";
 static const char kJpeg[] = "jpeg";
 static int kDefaultScreenshotQuality = 80;
 static int kFrameRateThresholdMs = 100;
 static int kCaptureRetryLimit = 2;
 
 }  // namespace
 
 RendererOverridesHandler::RendererOverridesHandler()
     : has_last_compositor_frame_metadata_(false),
       capture_retry_count_(0),
+      color_picker_enabled_(false),
       weak_factory_(this) {
   RegisterCommandHandler(
       devtools::DOM::setFileInputFiles::kName,
       base::Bind(
           &RendererOverridesHandler::GrantPermissionsForSetFileInputFiles,
           base::Unretained(this)));
   RegisterCommandHandler(
       devtools::Network::clearBrowserCache::kName,
       base::Bind(
           &RendererOverridesHandler::ClearBrowserCache,
@@ skipping 51 matching lines @@
       devtools::Page::stopScreencast::kName,
       base::Bind(
           &RendererOverridesHandler::PageStopScreencast,
           base::Unretained(this)));
   RegisterCommandHandler(
       devtools::Page::queryUsageAndQuota::kName,
       base::Bind(
           &RendererOverridesHandler::PageQueryUsageAndQuota,
           base::Unretained(this)));
   RegisterCommandHandler(
+      devtools::Page::setColorPickerEnabled::kName,
+      base::Bind(
+          &RendererOverridesHandler::PageSetColorPickerEnabled,
+          base::Unretained(this)));
+  RegisterCommandHandler(
       devtools::Input::emulateTouchFromMouseEvent::kName,
       base::Bind(
           &RendererOverridesHandler::InputEmulateTouchFromMouseEvent,
           base::Unretained(this)));
+  mouse_event_callback_ = base::Bind(
+      &RendererOverridesHandler::HandleMouseEvent,
+      base::Unretained(this));
 }
 
 RendererOverridesHandler::~RendererOverridesHandler() {}
 
 void RendererOverridesHandler::OnClientDetached() {
   if (screencast_command_ && host_)
     host_->SetTouchEventEmulationEnabled(false, false);
   screencast_command_ = NULL;
+  SetColorPickerEnabled(false);
 }
 
 void RendererOverridesHandler::OnSwapCompositorFrame(
     const cc::CompositorFrameMetadata& frame_metadata) {
   last_compositor_frame_metadata_ = frame_metadata;
   has_last_compositor_frame_metadata_ = true;
 
   if (screencast_command_)
     InnerSwapCompositorFrame();
+  if (color_picker_enabled_)
+    UpdateColorPickerFrame();
 }
 
 void RendererOverridesHandler::OnVisibilityChanged(bool visible) {
   if (!screencast_command_)
     return;
   NotifyScreencastVisibility(visible);
 }
 
 void RendererOverridesHandler::SetRenderViewHost(
     RenderViewHostImpl* host) {
   host_ = host;
   if (screencast_command_ && host)
     host->SetTouchEventEmulationEnabled(true, true);
+  if (color_picker_enabled_)
+    host->AddMouseEventCallback(mouse_event_callback_);
 }
 
 void RendererOverridesHandler::ClearRenderViewHost() {
+  if (host_)
+    host_->RemoveMouseEventCallback(mouse_event_callback_);
   host_ = NULL;
 }
 
 bool RendererOverridesHandler::OnSetTouchEventEmulationEnabled() {
   return screencast_command_.get() != NULL;
 }
 
 void RendererOverridesHandler::InnerSwapCompositorFrame() {
   if ((base::TimeTicks::Now() - last_frame_time_).InMilliseconds() <
           kFrameRateThresholdMs) {
@@ skipping 649 matching lines @@
 void RendererOverridesHandler::NotifyScreencastVisibility(bool visible) {
   if (visible)
     capture_retry_count_ = kCaptureRetryLimit;
   base::DictionaryValue* params = new base::DictionaryValue();
   params->SetBoolean(
       devtools::Page::screencastVisibilityChanged::kParamVisible, visible);
   SendNotification(
       devtools::Page::screencastVisibilityChanged::kName, params);
 }
 
+scoped_refptr<DevToolsProtocol::Response>
+RendererOverridesHandler::PageSetColorPickerEnabled(
+    scoped_refptr<DevToolsProtocol::Command> command) {
+  base::DictionaryValue* params = command->params();
+  bool color_picker_enabled = false;
+  if (!params || !params->GetBoolean(
+      devtools::Page::setColorPickerEnabled::kParamEnabled,
+      &color_picker_enabled)) {
+    return command->InvalidParamResponse(
+        devtools::Page::setColorPickerEnabled::kParamEnabled);
+  }
+
+  SetColorPickerEnabled(color_picker_enabled);
+  return command->SuccessResponse(NULL);
+}
+
+void RendererOverridesHandler::SetColorPickerEnabled(bool enabled) {
+  if (color_picker_enabled_ == enabled)
+    return;
+
+  color_picker_enabled_ = enabled;
+
+  if (!host_)
+    return;
+
+  if (enabled) {
+    host_->AddMouseEventCallback(mouse_event_callback_);
+    UpdateColorPickerFrame();
+  } else {
+    host_->RemoveMouseEventCallback(mouse_event_callback_);
+    color_picker_frame_.reset();
+
+    WebCursor pointer_cursor;
+    WebCursor::CursorInfo cursor_info;
+    cursor_info.type = blink::WebCursorInfo::TypePointer;
+    pointer_cursor.InitFromCursorInfo(cursor_info);
+    host_->SetCursor(pointer_cursor);
+  }
+}
+
+void RendererOverridesHandler::UpdateColorPickerFrame() {
+  if (!host_)
+    return;
+  RenderWidgetHostViewBase* view =
+      static_cast<RenderWidgetHostViewBase*>(host_->GetView());
+  if (!view)
+    return;
+
+  gfx::Size size = view->GetViewBounds().size();
+  view->CopyFromCompositingSurface(
+      gfx::Rect(size), size,
+      base::Bind(&RendererOverridesHandler::ColorPickerFrameUpdated,
+                 weak_factory_.GetWeakPtr()),
+      kN32_SkColorType);
+}
+
+void RendererOverridesHandler::ColorPickerFrameUpdated(
+    bool succeeded,
+    const SkBitmap& bitmap) {
+  if (succeeded)
+    color_picker_frame_ = bitmap;
+}
+
+bool RendererOverridesHandler::HandleMouseEvent(
+    const blink::WebMouseEvent& event) {
+  if (color_picker_frame_.drawsNothing())
+    return true;
+
+  if (event.button == blink::WebMouseEvent::ButtonLeft) {
+    color_picker_frame_.lockPixels();
+    SkColor color = color_picker_frame_.getColor(event.x, event.y);
+    color_picker_frame_.unlockPixels();
+    base::DictionaryValue* color_dict = new base::DictionaryValue();
+    color_dict->SetInteger("r", SkColorGetR(color));
+    color_dict->SetInteger("g", SkColorGetG(color));
+    color_dict->SetInteger("b", SkColorGetB(color));
+    color_dict->SetInteger("a", SkColorGetA(color));
+    base::DictionaryValue* response = new base::DictionaryValue();
+    response->Set(devtools::Page::colorPicked::kParamColor, color_dict);
+    SendNotification(devtools::Page::colorPicked::kName, response);
+  }
+
+  if (!host_)
+    return true;
+
+  // Due to platform limitations, we are using two different cursors
+  // depending on the platform. Mac and Win have large cursors with two circles
+  // for original spot and its magnified projection; Linux gets smaller (64 px)
+  // magnified projection only with centered hotspot.
+  // Mac Retina requires cursor to be > 120px in order to render smoothly.
+
+#if defined(OS_LINUX)
+  const float kCursorSize = 63;
+  const float kDiameter = 63;
+  const float kHotspotOffset = 32;
+  const float kHotspotRadius = 0;
+  const float kPixelSize = 9;
+#else
+  const float kCursorSize = 150;
+  const float kDiameter = 110;
+  const float kHotspotOffset = 25;
+  const float kHotspotRadius = 5;
+  const float kPixelSize = 10;
+#endif
+
+  float device_scale_factor = gfx::Screen::GetNativeScreen()->

[dgozman, 2014/08/17 04:28:59]

It's better to get this via |host_->GetScreenInfo|, which works right in case of
multiple screens.

[pfeldman, 2014/08/17 06:13:29]

Done.

+      GetPrimaryDisplay().device_scale_factor();
+
+  skia::RefPtr<SkCanvas> canvas = skia::AdoptRef(SkCanvas::NewRasterN32(
+      kCursorSize * device_scale_factor,
+      kCursorSize * device_scale_factor));
+  canvas->scale(device_scale_factor, device_scale_factor);
+
+  SkPaint paint;
+
+  // Paint original spot.
+  if (kHotspotRadius) {
+    paint.setStrokeWidth(2);
+    paint.setColor(SK_ColorDKGRAY);
+    paint.setStyle(SkPaint::kStroke_Style);
+    paint.setAntiAlias(true);
+    canvas->drawCircle(kHotspotOffset, kHotspotOffset, kHotspotRadius, paint);
+    canvas->drawLine(kHotspotOffset + kHotspotRadius - 1,

[dgozman, 2014/08/17 04:28:59]

This is actually |kHotspotOffset + kHotspotRadius / sqrt(2)|, right? Introduce a
const with right value?

[pfeldman, 2014/08/17 06:13:29]

Done.

[pfeldman, 2014/08/17 06:13:29]

Done.

+                     kHotspotOffset + kHotspotRadius - 1,
+                     kCursorSize / 2, kCursorSize / 2,
+                     paint);
+  }
+
+  // Clip circle for magnified projection.
+  float padding = (kCursorSize - kDiameter) / 2;
+  SkPath clip_path;
+  clip_path.addOval(SkRect::MakeXYWH(padding, padding, kDiameter, kDiameter));
+  clip_path.close();
+  canvas->clipPath(clip_path, SkRegion::kIntersect_Op, true);
+
+  // Project pixels.
+  int pixel_count = kDiameter / kPixelSize;
+  SkRect src_rect = SkRect::MakeXYWH(event.x - pixel_count / 2,
+                                     event.y - pixel_count / 2,
+                                     pixel_count, pixel_count);
+  SkRect dst_rect = SkRect::MakeXYWH(padding, padding, kDiameter, kDiameter);
+  canvas->drawBitmapRectToRect(color_picker_frame_, &src_rect, dst_rect);
+
+  // Paint outline circle.

[dgozman, 2014/08/17 04:28:59]

Wrong comment.

[pfeldman, 2014/08/17 06:13:29]

Done.

+  paint.setStrokeWidth(1);
+  paint.setAntiAlias(false);
+  paint.setColor(SK_ColorGRAY);
+  for (int i = 0; i < pixel_count; ++i) {
+    canvas->drawLine(padding + i * kPixelSize, padding,
+                     padding + i * kPixelSize, kCursorSize - padding, paint);
+    canvas->drawLine(padding, padding + i * kPixelSize,
+                     kCursorSize - padding, padding + i * kPixelSize, paint);
+  }
+
+  // Paint central pixel in red.
+  SkRect pixel = SkRect::MakeXYWH((kCursorSize - kPixelSize) / 2,
+                                  (kCursorSize - kPixelSize) / 2,
+                                  kPixelSize, kPixelSize);
+  paint.setColor(SK_ColorRED);
+  canvas->drawRect(pixel, paint);
+
+  // Paint outline.
+  paint.setStrokeWidth(2);
+  paint.setColor(SK_ColorDKGRAY);
+  paint.setAntiAlias(true);
+  paint.setStyle(SkPaint::kStroke_Style);
+  canvas->drawCircle(kCursorSize / 2, kCursorSize / 2, kDiameter / 2, paint);
+
+  SkBitmap result;
+  result.allocN32Pixels(kCursorSize * device_scale_factor,
+                        kCursorSize * device_scale_factor);
+  canvas->readPixels(&result, 0, 0);
+
+  WebCursor cursor;
+  WebCursor::CursorInfo cursor_info;
+  cursor_info.type = blink::WebCursorInfo::TypeCustom;
+  cursor_info.image_scale_factor = device_scale_factor;
+  cursor_info.custom_image = result;
+  cursor_info.hotspot =
+      gfx::Point(kHotspotOffset * device_scale_factor,
+                 kHotspotOffset * device_scale_factor);
+#if defined(OS_WIN)
+  cursor_info.external_handle = 0;
+#endif
+
+  cursor.InitFromCursorInfo(cursor_info);
+  DCHECK(host_);
+  host_->SetCursor(cursor);
+  return true;
+}
+
 // Input agent handlers  ------------------------------------------------------
 
 scoped_refptr<DevToolsProtocol::Response>
 RendererOverridesHandler::InputEmulateTouchFromMouseEvent(
     scoped_refptr<DevToolsProtocol::Command> command) {
   if (!screencast_command_)
     return command->InternalErrorResponse("Screencast should be turned on");
 
   base::DictionaryValue* params = command->params();
   if (!params)
@@ skipping 112 matching lines @@
     return command->InternalErrorResponse("Could not connect to view");
 
   if (event->type == WebInputEvent::MouseWheel)
     host_->ForwardWheelEvent(wheel_event);
   else
     host_->ForwardMouseEvent(mouse_event);
   return command->SuccessResponse(NULL);
 }
 
 }  // namespace content