Added support of relative mouse motion in Chromoting.

remoting/client/plugin/chromoting_instance.h

 // 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.
 
 // TODO(ajwong): We need to come up with a better description of the
 // responsibilities for each thread.
 
 #ifndef REMOTING_CLIENT_PLUGIN_CHROMOTING_INSTANCE_H_
 #define REMOTING_CLIENT_PLUGIN_CHROMOTING_INSTANCE_H_
 
 #include <string>
 
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "ppapi/c/pp_instance.h"
 #include "ppapi/c/pp_rect.h"
 #include "ppapi/c/pp_resource.h"
 #include "ppapi/cpp/instance.h"
+#include "ppapi/cpp/mouse_lock.h"
+#include "ppapi/cpp/point.h"
 #include "ppapi/cpp/var.h"
+#include "ppapi/utility/completion_callback_factory.h"
 #include "remoting/client/client_context.h"
 #include "remoting/client/client_user_interface.h"
 #include "remoting/client/key_event_mapper.h"
 #include "remoting/client/plugin/normalizing_input_filter.h"
 #include "remoting/client/plugin/pepper_input_handler.h"
 #include "remoting/client/plugin/pepper_plugin_thread_delegate.h"
 #include "remoting/proto/event.pb.h"
 #include "remoting/protocol/client_stub.h"
 #include "remoting/protocol/clipboard_stub.h"
 #include "remoting/protocol/connection_to_host.h"
 #include "remoting/protocol/cursor_shape_stub.h"
 #include "remoting/protocol/input_event_tracker.h"
 #include "remoting/protocol/mouse_input_filter.h"
 #include "remoting/protocol/negotiating_client_authenticator.h"
 #include "remoting/protocol/third_party_client_authenticator.h"
 #include "third_party/skia/include/core/SkPoint.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "third_party/skia/include/core/SkSize.h"
 
 namespace base {
 class DictionaryValue;
 }  // namespace base
 
 namespace pp {
+class ImageData;
 class InputEvent;
 class Module;
 }  // namespace pp
 
 namespace remoting {
 
 class ChromotingClient;
 class ChromotingStats;
 class ClientContext;
 class DelegatingSignalStrategy;
 class FrameConsumer;
 class FrameConsumerProxy;
 class PepperAudioPlayer;
 class PepperTokenFetcher;
 class PepperView;
 class RectangleUpdateDecoder;
 class SignalStrategy;
 
 struct ClientConfig;
 
 class ChromotingInstance :
       public ClientUserInterface,
       public protocol::ClipboardStub,
       public protocol::CursorShapeStub,
-      public pp::Instance {
+      public pp::Instance,
+      public pp::MouseLock {

[Wez, 2013/09/05 21:19:38]

Have you considered having PepperInputHandler derive from pp::MouseLock and
encapsulate the mouse-lock logic, rather than having ChromotingInstance do it?
Or breaking it out into its own component entirely?

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

Done. Moved it to PepperInputHandler.

  public:
   // Plugin API version. This should be incremented whenever the API
   // interface changes.
   static const int kApiVersion = 7;
 
   // Plugin API features. This allows orthogonal features to be supported
   // without bumping the API version.
   static const char kApiFeatures[];
 
   // Capabilities supported by the plugin that should also be supported by the
@@ skipping 15 matching lines @@
   static const int kApiMinScriptableVersion = 5;
 
   // Helper method to parse authentication_methods parameter.
   static bool ParseAuthMethods(const std::string& auth_methods,
                                ClientConfig* config);
 
   explicit ChromotingInstance(PP_Instance instance);
   virtual ~ChromotingInstance();
 
   // pp::Instance interface.
+  virtual void DidChangeFocus(bool has_focus) OVERRIDE;
   virtual void DidChangeView(const pp::View& view) OVERRIDE;
   virtual bool Init(uint32_t argc, const char* argn[],
                     const char* argv[]) OVERRIDE;
   virtual void HandleMessage(const pp::Var& message) OVERRIDE;
   virtual bool HandleInputEvent(const pp::InputEvent& event) OVERRIDE;
 
+  // pp::MouseLock interface.
+  virtual void MouseLockLost() OVERRIDE;
+
   // ClientUserInterface interface.
   virtual void OnConnectionState(protocol::ConnectionToHost::State state,
                                  protocol::ErrorCode error) OVERRIDE;
   virtual void OnConnectionReady(bool ready) OVERRIDE;
   virtual void SetCapabilities(const std::string& capabilities) OVERRIDE;
   virtual void SetPairingResponse(
       const protocol::PairingResponse& pairing_response) OVERRIDE;
   virtual void DeliverHostMessage(
       const protocol::ExtensionMessage& message) OVERRIDE;
   virtual protocol::ClipboardStub* GetClipboardStub() OVERRIDE;
@@ skipping 67 matching lines @@
   void HandleRemapKey(const base::DictionaryValue& data);
   void HandleTrapKey(const base::DictionaryValue& data);
   void HandleSendClipboardItem(const base::DictionaryValue& data);
   void HandleNotifyClientResolution(const base::DictionaryValue& data);
   void HandlePauseVideo(const base::DictionaryValue& data);
   void HandlePauseAudio(const base::DictionaryValue& data);
   void HandleOnPinFetched(const base::DictionaryValue& data);
   void HandleOnThirdPartyTokenFetched(const base::DictionaryValue& data);
   void HandleRequestPairing(const base::DictionaryValue& data);
   void HandleExtensionMessage(const base::DictionaryValue& data);
+  void HandleAllowMouseLockMessage();
 
   // Helper method called from Connect() to connect with parsed config.
   void ConnectWithConfig(const ClientConfig& config,
                          const std::string& local_jid);
 
   // Helper method to post messages to the webapp.
   void PostChromotingMessage(const std::string& method,
                              scoped_ptr<base::DictionaryValue> data);
 
   // Posts trapped keys to the web-app to handle.
@@ skipping 11 matching lines @@
 
   // Returns true if there is a ConnectionToHost and it is connected.
   bool IsConnected();
 
   // Used as the |FetchSecretCallback| for Me2Me connections.
   // Uses the PIN request dialog in the webapp to obtain the shared secret.
   void FetchSecretFromDialog(
       bool pairing_supported,
       const protocol::SecretFetchedCallback& secret_fetched_callback);
 
+  // Applies |cursor_image_| as the custom pointer or uses the standard arrow
+  // pointer if |cursor_image_| is not available.
+  void EnableMousePointer();
+
+  // Requests the browser to lock the mouse and hides the cursor.
+  void RequestMouseLock();
+
+  // Request the browser and restores the cursor once the lock is gone.

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

This wording seems b0rked!

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

Done.

+  void CancelMouseLock();
+
+  // Called when the browser locked the mouse.

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

nit: Does this take any action? Is this also called if mouse-lock fails, as the
presence of |error| implies?

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

Done.

+  void OnMouseLocked(int error);
+
   bool initialized_;
 
   PepperPluginThreadDelegate plugin_thread_delegate_;
   scoped_refptr<PluginThreadTaskRunner> plugin_task_runner_;
   ClientContext context_;
   scoped_refptr<RectangleUpdateDecoder> rectangle_decoder_;
   scoped_ptr<PepperView> view_;
   scoped_ptr<base::WeakPtrFactory<FrameConsumer> > view_weak_factory_;
   pp::View plugin_view_;
 
+  // True if the plugin is focused.

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

nit: has focus.

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

Done.

+  bool focused_;

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

nit: has_focus_;

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

Done.

+
+  // Custom cursor image sent by the host. When mouse lock is requested
+  // |cursor_image_| is set to NULL.

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

Why is this set to NULL when mouse-lock is requested?

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

Done.

+  scoped_ptr<pp::ImageData> cursor_image_;
+
+  // Hot spot for |cursor_image_|.
+  pp::Point cursor_hotspot_;
+
+  enum MouseLockState {
+    MouseLockDisabled,

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

nit: You've called this state "Disabled", but it's changed via a message called
"allow" - either rename this to "Disallowed", or the message to
"enableMouseLock", or "enableAutoMouseLock" or "enableUseMouseLock".

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

Done.

+    MouseLockOff,
+    MouseLockPending,

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

nit: MouseLockRequested or MouseLockRequestPending?

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

Done.

+    MouseLockOn,
+    MouseLockCancelling
+  };
+
+  MouseLockState mouse_lock_state_;
+
   // Contains the most-recently-reported desktop shape, if any.
   scoped_ptr<SkRegion> desktop_shape_;
 
   scoped_ptr<DelegatingSignalStrategy> signal_strategy_;
 
   scoped_ptr<protocol::ConnectionToHost> host_connection_;
   scoped_ptr<ChromotingClient> client_;
 
   // Input pipeline components, in reverse order of distance from input source.
   protocol::MouseInputFilter mouse_input_filter_;
   protocol::InputEventTracker input_tracker_;
   KeyEventMapper key_mapper_;
   scoped_ptr<protocol::InputFilter> normalizing_input_filter_;
   PepperInputHandler input_handler_;
 
   // PIN Fetcher.
   bool use_async_pin_dialog_;
   protocol::SecretFetchedCallback secret_fetched_callback_;
 
   base::WeakPtr<PepperTokenFetcher> pepper_token_fetcher_;
 
+  pp::CompletionCallbackFactory<ChromotingInstance> callback_factory_;
+
   // Weak reference to this instance, used for global logging and task posting.
   base::WeakPtrFactory<ChromotingInstance> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromotingInstance);
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_CLIENT_PLUGIN_CHROMOTING_INSTANCE_H_