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 "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"
@@ skipping 11 matching lines @@
 static int kDefaultScreenshotQuality = 80;
 static int kFrameRateThresholdMs = 100;
 static int kCaptureRetryLimit = 2;
 
 }  // namespace
 
 RendererOverridesHandler::RendererOverridesHandler(DevToolsAgentHost* agent)
     : agent_(agent),
       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)));
 }
 
 RendererOverridesHandler::~RendererOverridesHandler() {}
 
 void RendererOverridesHandler::OnClientDetached() {
   RenderViewHostImpl* host = GetRenderViewHostImpl();
   if (screencast_command_ && host)
     host->SetTouchEventEmulationEnabled(false, false);
   screencast_command_ = NULL;
 }
 
 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::OnRenderViewHostChanged() {
   RenderViewHostImpl* host = GetRenderViewHostImpl();
@@ 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;
+  if (!params || !params->GetBoolean(
+      devtools::Page::setColorPickerEnabled::kParamEnabled,
+      &color_picker_enabled)) {
+    return command->InvalidParamResponse(
+        devtools::Page::setColorPickerEnabled::kParamEnabled);
+  }
+  RenderViewHostImpl* host = GetRenderViewHostImpl();
+  if (!host)
+    return command->InternalErrorResponse("Could not connect to view");
+
+  SetColorPickerEnabled(color_picker_enabled);
+  return command->SuccessResponse(NULL);
+}
+
+void RendererOverridesHandler::SetColorPickerEnabled(bool enabled) {
+  if (color_picker_enabled_ == enabled)
+    return;
+
+  RenderViewHostImpl* host = GetRenderViewHostImpl();
+  color_picker_enabled_ = enabled;
+
+  if (enabled) {
+    UpdateColorPickerFrame();
+    host->SetInterceptingMouseCallback(
+        base::Bind(&RendererOverridesHandler::HandleMouseEvent,
+                   weak_factory_.GetWeakPtr()));
+  } else {
+    color_picker_frame_.reset();
+    host->SetInterceptingMouseCallback(
+        RenderWidgetHostImpl::InterceptingMouseCallback());
+  }
+
+  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() {
+  RenderViewHostImpl* host = GetRenderViewHostImpl();
+  if (!host)
+    return;
+  RenderWidgetHostViewBase* view =
+      static_cast<RenderWidgetHostViewBase*>(host->GetView());
+  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;
+}
+
+void RendererOverridesHandler::HandleMouseEvent(
+    const blink::WebMouseEvent& event) {
+
+  if (color_picker_frame_.drawsNothing()) {
+    if (event.button == blink::WebMouseEvent::ButtonLeft)
+      SetColorPickerEnabled(false);
+    return;
+  }
+
+  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);
+  }
+
+  const int kCursorSize = 150;
+  const int kDiameter = 110;
+  const int kHotspotRadius = 5;
+  const int kPixelSize = 10;
+  int padding = (kCursorSize - kDiameter) / 2;
+  int hotspot = padding + kHotspotRadius;
+
+  skia::RefPtr<SkCanvas> canvas =
+      skia::AdoptRef(SkCanvas::NewRasterN32(kCursorSize, kCursorSize));
+
+  SkPaint paint;
+  paint.setStrokeWidth(2);
+  paint.setColor(SK_ColorDKGRAY);
+  paint.setStyle(SkPaint::kStroke_Style);
+  paint.setAntiAlias(true);
+  canvas->drawCircle(hotspot, hotspot, kHotspotRadius, paint);
+  canvas->drawLine(hotspot + kHotspotRadius - 1,
+                   hotspot + kHotspotRadius - 1,
+                   kCursorSize / 2, kCursorSize / 2,
+                   paint);
+
+  SkPath clip_path;
+  clip_path.addOval(SkRect::MakeXYWH(padding, padding, kDiameter, kDiameter));
+  clip_path.close();
+  canvas->clipPath(clip_path, SkRegion::kIntersect_Op, true);
+
+  SkRect src_rect = SkRect::MakeXYWH(event.x - 5, event.y - 5, 11, 11);
+  SkRect dst_rect = SkRect::MakeXYWH(padding, padding, kDiameter, kDiameter);
+  canvas->drawBitmapRectToRect(color_picker_frame_, &src_rect, dst_rect);
+
+  paint.setStrokeWidth(1);
+  paint.setAntiAlias(false);
+  paint.setColor(SK_ColorGRAY);
+  for (int i = padding; i < kCursorSize - padding; i += kPixelSize) {
+    canvas->drawLine(i, padding, i, kCursorSize - padding, paint);
+    canvas->drawLine(padding, i, kCursorSize - padding, i, paint);
+  }
+
+  SkRect pixel = SkRect::MakeXYWH(kCursorSize / 2 - kHotspotRadius,
+                                  kCursorSize / 2 - kHotspotRadius,
+                                  kPixelSize, kPixelSize);
+  paint.setColor(SK_ColorRED);
+  canvas->drawRect(pixel, paint);
+
+  paint.setStrokeWidth(2);
+  paint.setColor(SK_ColorDKGRAY);
+  paint.setAntiAlias(true);
+  canvas->drawCircle(kCursorSize / 2, kCursorSize / 2, kDiameter / 2, paint);
+
+  SkBitmap result;
+  result.allocN32Pixels(kCursorSize, kCursorSize);
+  canvas->readPixels(&result, 0, 0);
+
+  WebCursor cursor;
+  WebCursor::CursorInfo cursor_info;
+  cursor_info.type = blink::WebCursorInfo::TypeCustom;
+  cursor_info.image_scale_factor = 1;
+  cursor_info.custom_image = result;
+  cursor_info.hotspot =
+      gfx::Point(hotspot, hotspot);
+#if defined(OS_WIN)
+  cursor_info.external_handle = 0;
+#endif
+
+  cursor.InitFromCursorInfo(cursor_info);
+  RenderViewHostImpl* rvh = GetRenderViewHostImpl();
+  if (rvh)
+    rvh->SetCursor(cursor);
+}
+
 // 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 115 matching lines @@
     host->ForwardMouseEvent(mouse_event);
   return command->SuccessResponse(NULL);
 }
 
 RenderViewHostImpl* RendererOverridesHandler::GetRenderViewHostImpl() {
   return static_cast<RenderViewHostImpl*>(
       agent_->GetWebContents()->GetRenderViewHost());
 }
 
 }  // namespace content