DevTools: make eye dropper live (refresh on frame update).

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"
@@ skipping 57 matching lines @@
 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),
+      last_cursor_x_(-1),
+      last_cursor_y_(-1),
       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 94 matching lines @@
 
 void RendererOverridesHandler::OnVisibilityChanged(bool visible) {
   if (!screencast_command_)
     return;
   NotifyScreencastVisibility(visible);
 }
 
 void RendererOverridesHandler::SetRenderViewHost(
     RenderViewHostImpl* host) {
   host_ = host;
-  if (screencast_command_ && host)
+  if (!host)
+    return;
+  if (screencast_command_)
     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;
+  ResetColorPickerFrame();
 }
 
 bool RendererOverridesHandler::OnSetTouchEventEmulationEnabled() {
   return screencast_command_.get() != NULL;
 }
 
 void RendererOverridesHandler::InnerSwapCompositorFrame() {
   if ((base::TimeTicks::Now() - last_frame_time_).InMilliseconds() <
           kFrameRateThresholdMs) {
     return;
@@ skipping 678 matching lines @@
   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();
+    ResetColorPickerFrame();
 
     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::ResetColorPickerFrame() {
+  color_picker_frame_.reset();
+  last_cursor_x_ = -1;
+  last_cursor_y_ = -1;
+}
+
 void RendererOverridesHandler::ColorPickerFrameUpdated(
     bool succeeded,
     const SkBitmap& bitmap) {
-  if (succeeded)
+  if (!color_picker_enabled_)
+    return;
+
+  if (succeeded) {
     color_picker_frame_ = bitmap;
+    UpdateColorPickerCursor();
+  }
 }
 
 bool RendererOverridesHandler::HandleMouseEvent(
     const blink::WebMouseEvent& event) {
+  last_cursor_x_ = event.x;
+  last_cursor_y_ = event.y;
   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();
+    if (last_cursor_x_ < 0 || last_cursor_x_ >= color_picker_frame_.width() ||
+        last_cursor_y_ < 0 || last_cursor_y_ >= color_picker_frame_.height()) {
+      return true;
+    }
+
+    SkAutoLockPixels lock_image(color_picker_frame_);
+    SkColor color = color_picker_frame_.getColor(last_cursor_x_,
+                                                 last_cursor_y_);
     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);
   }
+  UpdateColorPickerCursor();
+  return true;
+}
 
-  if (!host_)
-    return true;
+void RendererOverridesHandler::UpdateColorPickerCursor() {
+  if (!host_ || color_picker_frame_.drawsNothing())
+    return;
+
+  if (last_cursor_x_ < 0 || last_cursor_x_ >= color_picker_frame_.width() ||
+      last_cursor_y_ < 0 || last_cursor_y_ >= color_picker_frame_.height()) {
+    return;
+  }
+
   RenderWidgetHostViewBase* view = static_cast<RenderWidgetHostViewBase*>(
       host_->GetView());
   if (!view)
-    return true;
+    return;
 
   // 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;
@@ skipping 36 matching lines @@
 
   // 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,
+  SkRect src_rect = SkRect::MakeXYWH(last_cursor_x_ - pixel_count / 2,
+                                     last_cursor_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 grid.
   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);
+  paint.setStyle(SkPaint::kStroke_Style);
   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");
 
@@ skipping 114 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