Added support of relative mouse motion in Chromoting.

remoting/client/plugin/chromoting_instance.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 "remoting/client/plugin/chromoting_instance.h"
 
+#include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/strings/string_split.h"
@@ skipping 31 matching lines @@
 #undef PostMessage
 #endif
 
 namespace remoting {
 
 namespace {
 
 // 32-bit BGRA is 4 bytes per pixel.
 const int kBytesPerPixel = 4;
 
+#if defined(ARCH_CPU_LITTLE_ENDIAN)
+const uint32_t kPixelAlphaMask = 0xff000000;
+#else  // !defined(ARCH_CPU_LITTLE_ENDIAN)
+const uint32_t kPixelAlphaMask = 0x000000ff;
+#endif  // !defined(ARCH_CPU_LITTLE_ENDIAN)
+
 // Default DPI to assume for old clients that use notifyClientResolution.
 const int kDefaultDPI = 96;
 
 // Interval at which to sample performance statistics.
 const int kPerfStatsIntervalMs = 1000;
 
 // URL scheme used by Chrome apps and extensions.
 const char kChromeExtensionUrlScheme[] = "chrome-extension";
 
 // Maximum width and height of a mouse cursor supported by PPAPI.
@@ skipping 50 matching lines @@
     case protocol::CHANNEL_CONNECTION_ERROR:
     case protocol::SIGNALING_ERROR:
     case protocol::SIGNALING_TIMEOUT:
     case protocol::UNKNOWN_ERROR:
       return "NETWORK_FAILURE";
   }
   DLOG(FATAL) << "Unknown error code" << error;
   return std::string();
 }
 
+// Returns true |pixel| is not completely transparent.

[Wez, 2013/09/05 20:24:45]

nit: "... true if ..."

[alexeypa (please no reviews), 2013/09/06 20:00:17]

Done.

+bool IsVisiblePixel(uint32_t pixel) {
+  return (pixel & kPixelAlphaMask) != 0;
+}
+
 // This flag blocks LOGs to the UI if we're already in the middle of logging
 // to the UI. This prevents a potential infinite loop if we encounter an error
 // while sending the log message to the UI.
 bool g_logging_to_plugin = false;
 bool g_has_logging_instance = false;
 base::LazyInstance<scoped_refptr<base::SingleThreadTaskRunner> >::Leaky
     g_logging_task_runner = LAZY_INSTANCE_INITIALIZER;
 base::LazyInstance<base::WeakPtr<ChromotingInstance> >::Leaky
     g_logging_instance = LAZY_INSTANCE_INITIALIZER;
 base::LazyInstance<base::Lock>::Leaky
     g_logging_lock = LAZY_INSTANCE_INITIALIZER;
 logging::LogMessageHandlerFunction g_logging_old_handler = NULL;
 
 }  // namespace
 
 // String sent in the "hello" message to the webapp to describe features.
 const char ChromotingInstance::kApiFeatures[] =
     "highQualityScaling injectKeyEvent sendClipboardItem remapKey trapKey "
     "notifyClientResolution pauseVideo pauseAudio asyncPin thirdPartyAuth "
-    "pinlessAuth extensionMessage";
+    "pinlessAuth extensionMessage allowMouseLock";
 
 const char ChromotingInstance::kRequestedCapabilities[] = "";
 const char ChromotingInstance::kSupportedCapabilities[] = "desktopShape";
 
 bool ChromotingInstance::ParseAuthMethods(const std::string& auth_methods_str,
                                           ClientConfig* config) {
   std::vector<std::string> auth_methods;
   base::SplitString(auth_methods_str, ',', &auth_methods);
   for (std::vector<std::string>::iterator it = auth_methods.begin();
        it != auth_methods.end(); ++it) {
     protocol::AuthenticationMethod authentication_method =
         protocol::AuthenticationMethod::FromString(*it);
     if (authentication_method.is_valid())
       config->authentication_methods.push_back(authentication_method);
   }
   if (config->authentication_methods.empty()) {
     LOG(ERROR) << "No valid authentication methods specified.";
     return false;
   }
 
   return true;
 }
 
 ChromotingInstance::ChromotingInstance(PP_Instance pp_instance)
     : pp::Instance(pp_instance),
+      pp::MouseLock(this),
       initialized_(false),
       plugin_task_runner_(new PluginThreadTaskRunner(&plugin_thread_delegate_)),
       context_(plugin_task_runner_.get()),
+      focused_(false),
+      mouse_lock_state_(MouseLockDisabled),
       input_tracker_(&mouse_input_filter_),
       key_mapper_(&input_tracker_),
       normalizing_input_filter_(CreateNormalizingInputFilter(&key_mapper_)),
       input_handler_(normalizing_input_filter_.get()),
       use_async_pin_dialog_(false),
+      callback_factory_(this),
       weak_factory_(this) {
   RequestInputEvents(PP_INPUTEVENT_CLASS_MOUSE | PP_INPUTEVENT_CLASS_WHEEL);
   RequestFilteringInputEvents(PP_INPUTEVENT_CLASS_KEYBOARD);
 
   // Resister this instance to handle debug log messsages.
   RegisterLoggingInstance();
 
   // Send hello message.
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetInteger("apiVersion", kApiVersion);
@@ skipping 106 matching lines @@
   } else if (method == "useAsyncPinDialog") {
     use_async_pin_dialog_ = true;
   } else if (method == "onPinFetched") {
     HandleOnPinFetched(*data);
   } else if (method == "onThirdPartyTokenFetched") {
     HandleOnThirdPartyTokenFetched(*data);
   } else if (method == "requestPairing") {
     HandleRequestPairing(*data);
   } else if (method == "extensionMessage") {
     HandleExtensionMessage(*data);
+  } else if (method == "allowMouseLock") {
+    HandleAllowMouseLockMessage();
   }
 }
 
+void ChromotingInstance::DidChangeFocus(bool has_focus) {
+  DCHECK(plugin_task_runner_->BelongsToCurrentThread());
+
+  focused_ = has_focus;
+  RequestMouseLock();

[Wez, 2013/09/05 20:24:45]

nit: It looks strange to call RequestMouseLock() in the case that we're becoming
un-focused.

Does mouse lock fail in that case, BTW?

[alexeypa (please no reviews), 2013/09/06 20:00:17]

RequestMouseLock() checks whether the plugin is focused.
Yes, as far as I can tell.

+}
+
 void ChromotingInstance::DidChangeView(const pp::View& view) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   plugin_view_ = view;
   if (view_) {
     view_->SetView(view);
     mouse_input_filter_.set_input_size(view_->get_view_size_dips());
   }
 }
 
 bool ChromotingInstance::HandleInputEvent(const pp::InputEvent& event) {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   if (!IsConnected())
     return false;
 
-  return input_handler_.HandleInputEvent(event);
+  return input_handler_.HandleInputEvent(event,
+                                         mouse_lock_state_ == MouseLockOn);
+}
+
+void ChromotingInstance::MouseLockLost() {
+  DCHECK(plugin_task_runner_->BelongsToCurrentThread());
+  DCHECK(mouse_lock_state_ == MouseLockOn ||
+         mouse_lock_state_ == MouseLockCancelling);
+
+  mouse_lock_state_ = MouseLockOff;
+  EnableMousePointer();
 }
 
 void ChromotingInstance::SetDesktopSize(const SkISize& size,
                                         const SkIPoint& dpi) {
   mouse_input_filter_.set_output_size(size);
 
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetInteger("width", size.width());
   data->SetInteger("height", size.height());
   if (dpi.x())
@@ skipping 120 matching lines @@
 void ChromotingInstance::InjectClipboardEvent(
     const protocol::ClipboardEvent& event) {
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetString("mimeType", event.mime_type());
   data->SetString("item", event.data());
   PostChromotingMessage("injectClipboardItem", data.Pass());
 }
 
 void ChromotingInstance::SetCursorShape(
     const protocol::CursorShapeInfo& cursor_shape) {
+  COMPILE_ASSERT(sizeof(uint32_t) == kBytesPerPixel, rgba_pixels_are_32bit);
+
   if (!cursor_shape.has_data() ||
       !cursor_shape.has_width() ||
       !cursor_shape.has_height() ||
       !cursor_shape.has_hotspot_x() ||
       !cursor_shape.has_hotspot_y()) {
     return;
   }
 
   int width = cursor_shape.width();
   int height = cursor_shape.height();
@@ skipping 16 matching lines @@
   }
 
   if (pp::ImageData::GetNativeImageDataFormat() !=
       PP_IMAGEDATAFORMAT_BGRA_PREMUL) {
     VLOG(2) << "Unable to set cursor shape - non-native image format";
     return;
   }
 
   int hotspot_x = cursor_shape.hotspot_x();
   int hotspot_y = cursor_shape.hotspot_y();
+  int bytes_per_row = width * kBytesPerPixel;
+  int src_stride = width;
+  const uint32_t* src_row_data = reinterpret_cast<const uint32_t*>(
+      cursor_shape.data().data());
+  const uint32_t* src_row_data_end = src_row_data + src_stride * height;
 
-  int bytes_per_row = width * kBytesPerPixel;
-  const uint8* src_row_data = reinterpret_cast<const uint8*>(
-      cursor_shape.data().data());
-  int stride = bytes_per_row;
+  // See if the cursor image completely consists of transparent pixels.

[Wez, 2013/09/05 20:24:45]

nit: consists completely

[alexeypa (please no reviews), 2013/09/06 20:00:17]

Done.

+  bool mouse_lock_requested = (mouse_lock_state_ != MouseLockDisabled) &&
+      (std::find_if(src_row_data,
+                    src_row_data_end,
+                    &IsVisiblePixel) == src_row_data_end);

[Wez, 2013/09/05 20:24:45]

nit: Move this find_if() into an IsVisibleRow() helper alongside IsVisiblePixel.

[alexeypa (please no reviews), 2013/09/06 20:00:17]

Done.

+  if (mouse_lock_requested) {
+    // Request mouse lock.
+    cursor_image_.reset();
+    RequestMouseLock();
+  } else {
+    // If the cursor exceeds the size permitted by PPAPI then crop it, keeping
+    // the hotspot as close to the center of the new cursor shape as possible.

[Wez, 2013/09/05 20:24:45]

Nit, can we move this crop logic into a CropCursor() helper function without
complicating things too much?

[alexeypa (please no reviews), 2013/09/06 20:00:17]

Not sure. This code updates a bunch of local variables meaning a lot of
parameters passed in and out the function. I don't think it belong to this CL.

+    if (height > kMaxCursorHeight) {
+      int y = hotspot_y - (kMaxCursorHeight / 2);
+      y = std::max(y, 0);
+      y = std::min(y, height - kMaxCursorHeight);
 
-  // If the cursor exceeds the size permitted by PPAPI then crop it, keeping
-  // the hotspot as close to the center of the new cursor shape as possible.
-  if (height > kMaxCursorHeight) {
-    int y = hotspot_y - (kMaxCursorHeight / 2);
-    y = std::max(y, 0);
-    y = std::min(y, height - kMaxCursorHeight);
+      src_row_data += src_stride * y;
+      height = kMaxCursorHeight;
+      hotspot_y -= y;
+    }
+    if (width > kMaxCursorWidth) {
+      int x = hotspot_x - (kMaxCursorWidth / 2);
+      x = std::max(x, 0);
+      x = std::min(x, height - kMaxCursorWidth);
 
-    src_row_data += stride * y;
-    height = kMaxCursorHeight;
-    hotspot_y -= y;
+      src_row_data += x;
+      width = kMaxCursorWidth;
+      bytes_per_row = width * kBytesPerPixel;
+      hotspot_x -= x;
+    }
+
+    cursor_image_.reset(new pp::ImageData(this, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
+                                          pp::Size(width, height), false));
+    cursor_hotspot_ = pp::Point(hotspot_x, hotspot_y);
+
+    uint8* dst_row_data = reinterpret_cast<uint8*>(cursor_image_->data());
+    for (int row = 0; row < height; row++) {
+      memcpy(dst_row_data, src_row_data, bytes_per_row);
+      src_row_data += src_stride;
+      dst_row_data += cursor_image_->stride();
+    }
+
+    // Cancel mouse lock if any and apply the new cursor image.

[Wez, 2013/09/05 20:24:45]

nit: if any and -> if active, and

[alexeypa (please no reviews), 2013/09/06 20:00:17]

Done.

+    CancelMouseLock();
   }
-  if (width > kMaxCursorWidth) {
-    int x = hotspot_x - (kMaxCursorWidth / 2);
-    x = std::max(x, 0);
-    x = std::min(x, height - kMaxCursorWidth);
-
-    src_row_data += x * kBytesPerPixel;
-    width = kMaxCursorWidth;
-    bytes_per_row = width * kBytesPerPixel;
-    hotspot_x -= x;
-  }
-
-  pp::ImageData cursor_image(this, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
-                             pp::Size(width, height), false);
-
-  uint8* dst_row_data = reinterpret_cast<uint8*>(cursor_image.data());
-  for (int row = 0; row < height; row++) {
-    memcpy(dst_row_data, src_row_data, bytes_per_row);
-    src_row_data += stride;
-    dst_row_data += cursor_image.stride();
-  }
-
-  pp::MouseCursor::SetCursor(this, PP_MOUSECURSOR_TYPE_CUSTOM,
-                             cursor_image,
-                             pp::Point(hotspot_x, hotspot_y));
 }
 
 void ChromotingInstance::OnFirstFrameReceived() {
   scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   PostChromotingMessage("onFirstFrameReceived", data.Pass());
 }
 
 void ChromotingInstance::HandleConnect(const base::DictionaryValue& data) {
   ClientConfig config;
   std::string local_jid;
@@ skipping 299 matching lines @@
   }
   if (!IsConnected()) {
     return;
   }
   protocol::ExtensionMessage message;
   message.set_type(type);
   message.set_data(message_data);
   host_connection_->host_stub()->DeliverClientMessage(message);
 }
 
+void ChromotingInstance::HandleAllowMouseLockMessage() {
+  DCHECK_EQ(mouse_lock_state_, MouseLockDisabled);
+  mouse_lock_state_ = MouseLockOff;
+}
+
 ChromotingStats* ChromotingInstance::GetStats() {
   if (!client_.get())
     return NULL;
   return client_->GetStats();
 }
 
 void ChromotingInstance::PostChromotingMessage(
     const std::string& method,
     scoped_ptr<base::DictionaryValue> data) {
   scoped_ptr<base::DictionaryValue> message(new base::DictionaryValue());
@@ skipping 156 matching lines @@
   std::string url_scheme = url.substr(url_components.scheme.begin,
                                       url_components.scheme.len);
   return url_scheme == kChromeExtensionUrlScheme;
 }
 
 bool ChromotingInstance::IsConnected() {
   return host_connection_.get() &&
     (host_connection_->state() == protocol::ConnectionToHost::CONNECTED);
 }
 
+void ChromotingInstance::EnableMousePointer() {

[Wez, 2013/09/05 20:24:45]

This name doesn't feel right; you're setting the cursor shape, so call it
SetMouseCursor() or UpdateMouseCursor()?

[alexeypa (please no reviews), 2013/09/06 20:00:17]

Done.

+  DCHECK(plugin_task_runner_->BelongsToCurrentThread());
+  DCHECK(mouse_lock_state_ == MouseLockDisabled ||
+         mouse_lock_state_ == MouseLockOff);
+
+  if (cursor_image_) {
+    pp::MouseCursor::SetCursor(this, PP_MOUSECURSOR_TYPE_CUSTOM,
+                               *cursor_image_,
+                               cursor_hotspot_);
+  } else {
+    // THe browser cancelled mouse lock but we don't have a cursor to show. Use
+    // the standard arrow pointer instead.

[Wez, 2013/09/05 20:24:45]

Will we also be in this state if the host never sent us a cursor shape at all,
in which case comment could be:

"If there is no cursor shape stored, either because the host never supplied one,
or we were previously in mouse-lock mode, then use a standard arrow pointer."

[alexeypa (please no reviews), 2013/09/06 20:00:17]

Done.

+    pp::MouseCursor::SetCursor(this, PP_MOUSECURSOR_TYPE_POINTER);
+  }
+}
+
+void ChromotingInstance::RequestMouseLock() {
+  DCHECK(plugin_task_runner_->BelongsToCurrentThread());
+
+  // Request mouse lock if the plugin is focused, mouse lock requested by

[Wez, 2013/09/05 20:24:45]

nit: lock if -> lock only if

[alexeypa (please no reviews), 2013/09/06 20:00:17]

Done.

+  // the host and no callback is pending.

[Wez, 2013/09/05 20:24:45]

nit: mouse lock requested by the host -> the host-supplied cursor is empty

[alexeypa (please no reviews), 2013/09/06 20:00:17]

Done.

+  if (focused_ && !cursor_image_ && mouse_lock_state_ == MouseLockOff) {

[Wez, 2013/09/05 20:24:45]

nit: I think this function would be more readable w/ a set of three ifs w/
early-exits.

[alexeypa (please no reviews), 2013/09/06 20:00:17]

Six lines instead of one? I don't think so.

+    pp::CompletionCallback callback =
+        callback_factory_.NewCallback(&ChromotingInstance::OnMouseLocked);
+    int result = pp::MouseLock::LockMouse(callback);
+    DCHECK_EQ(result, PP_OK_COMPLETIONPENDING);
+
+    // Hide the cursor to workaround http://crbug.com/285809.

[Wez, 2013/09/05 20:24:45]

nit: Suggest: "Hide cursor to avoid it becoming a black square (see
crbug.com/285809."

[alexeypa (please no reviews), 2013/09/06 20:00:17]

Done.

+    pp::MouseCursor::SetCursor(this, PP_MOUSECURSOR_TYPE_NONE);
+    mouse_lock_state_ = MouseLockPending;

[Wez, 2013/09/05 20:24:45]

nit: Since the comment "Hide the cursor" doesn't apply to this line, have a
blank line between it and the SetCursor() line :)

[alexeypa (please no reviews), 2013/09/06 20:00:17]

Done.

+  }
+}
+
+void ChromotingInstance::CancelMouseLock() {
+  DCHECK(plugin_task_runner_->BelongsToCurrentThread());
+
+  switch (mouse_lock_state_) {
+    case MouseLockDisabled:
+    case MouseLockOff:
+      EnableMousePointer();
+      break;
+
+    case MouseLockCancelling:
+      break;
+
+    case MouseLockPending:
+      // Let the callback know that the operation should be cancelled.

[Wez, 2013/09/05 20:24:45]

nit: Clarify here that we can't call UnlockMouse() while a LockMouse() request
is pending, if that's the case. Otherwise, just call UnlockMouse here. :)

[alexeypa (please no reviews), 2013/09/06 20:00:17]

Done.

+      mouse_lock_state_ = MouseLockCancelling;
+      break;
+
+    case MouseLockOn:
+      pp::MouseLock::UnlockMouse();
+
+      // Wait until MouseLockLost() is called.

[Wez, 2013/09/05 20:24:45]

nit: Suggest "Note that mouse-lock has been cancelled. We will continue to
receive locked events until MouseLockLost() is called back."

[alexeypa (please no reviews), 2013/09/06 20:00:17]

Done.

+      mouse_lock_state_ = MouseLockCancelling;
+      break;
+
+    default:
+      NOTREACHED();
+  }
+}
+
+void ChromotingInstance::OnMouseLocked(int error) {
+  DCHECK(plugin_task_runner_->BelongsToCurrentThread());
+  DCHECK(mouse_lock_state_ == MouseLockPending ||
+         mouse_lock_state_ == MouseLockCancelling);
+
+  bool cancel = (mouse_lock_state_ == MouseLockCancelling);

[Wez, 2013/09/05 20:24:45]

nit: cancel -> should_cancel?

[alexeypa (please no reviews), 2013/09/06 20:00:17]

Done.

+
+  // See if the operation succeeded.
+  if (error == PP_OK) {
+    mouse_lock_state_ = MouseLockOn;
+  } else {
+    mouse_lock_state_ = MouseLockOff;
+    EnableMousePointer();
+  }
+
+  // Cancel as needed.
+  if (cancel)
+    CancelMouseLock();

[Wez, 2013/09/05 20:24:45]

So we can't dispatch the mouse-lock cancel until a previous mouse-lock request
has completed? That seems an unnecessary restriction in the API. :(

[alexeypa (please no reviews), 2013/09/06 20:00:17]

I don't know. I implemented it this way because the state logic is simpler this
way.

+}
+
 }  // namespace remoting