Adding ability to stream windows and inject events to them

remoting/host/input_injector_mac.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/host/input_injector.h"
 
 #include <ApplicationServices/ApplicationServices.h>
 #include <Carbon/Carbon.h>
 #include <algorithm>
 
@@ skipping 42 matching lines @@
 using protocol::ClipboardEvent;
 using protocol::KeyEvent;
 using protocol::TextEvent;
 using protocol::MouseEvent;
 
 // A class to generate events on Mac.
 class InputInjectorMac : public InputInjector {
  public:
   explicit InputInjectorMac(
       scoped_refptr<base::SingleThreadTaskRunner> task_runner);
+
   virtual ~InputInjectorMac();
 
   // ClipboardStub interface.
   virtual void InjectClipboardEvent(const ClipboardEvent& event) OVERRIDE;
 
   // InputStub interface.
   virtual void InjectKeyEvent(const KeyEvent& event) OVERRIDE;
   virtual void InjectTextEvent(const TextEvent& event) OVERRIDE;
   virtual void InjectMouseEvent(const MouseEvent& event) OVERRIDE;
 
   // InputInjector interface.
   virtual void Start(
       scoped_ptr<protocol::ClipboardStub> client_clipboard) OVERRIDE;
+  void EnableWindowInjection(webrtc::WindowId window_id);
 
  private:
+  CGWindowID window_id_input_injector_mac_;

[Wez, 2014/08/01 23:41:53]

Members appear after type definitions (see style guide :)

[ronakvora do not use, 2014/08/05 19:54:49]

Got it. Removed anyhow since it was not needed, as you noted below :).

   // The actual implementation resides in InputInjectorMac::Core class.
   class Core : public base::RefCountedThreadSafe<Core> {
    public:
     explicit Core(scoped_refptr<base::SingleThreadTaskRunner> task_runner);
 
     // Mirrors the ClipboardStub interface.
     void InjectClipboardEvent(const ClipboardEvent& event);
 
     // Mirrors the InputStub interface.
     void InjectKeyEvent(const KeyEvent& event);
     void InjectTextEvent(const TextEvent& event);
     void InjectMouseEvent(const MouseEvent& event);
 
     // Mirrors the InputInjector interface.
     void Start(scoped_ptr<protocol::ClipboardStub> client_clipboard);
+    void EnableWindowInjection(CGWindowID window_id);
 
     void Stop();
 
    private:
     friend class base::RefCountedThreadSafe<Core>;
     virtual ~Core();
+    CGRect FindCGRectOfWindow(webrtc::MacDesktopConfiguration desktop_config);
 
     scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
     webrtc::DesktopVector mouse_pos_;
     uint32 mouse_button_state_;
     scoped_ptr<Clipboard> clipboard_;
     CGEventFlags left_modifiers_;
     CGEventFlags right_modifiers_;
+    CGWindowID window_id_core_;
+    bool window_injection_enabled_;
 
     DISALLOW_COPY_AND_ASSIGN(Core);
   };
 
   scoped_refptr<Core> core_;
 
   DISALLOW_COPY_AND_ASSIGN(InputInjectorMac);
 };
 
 InputInjectorMac::InputInjectorMac(
@@ skipping 19 matching lines @@
 
 void InputInjectorMac::InjectMouseEvent(const MouseEvent& event) {
   core_->InjectMouseEvent(event);
 }
 
 void InputInjectorMac::Start(
     scoped_ptr<protocol::ClipboardStub> client_clipboard) {
   core_->Start(client_clipboard.Pass());
 }
 
+void InputInjectorMac::EnableWindowInjection(webrtc::WindowId window_id) {
+  window_id_input_injector_mac_ = (CGWindowID) window_id;

[Wez, 2014/08/01 23:41:53]

Why do you need to store this in the InputInjector - isn't the Core storing it
already?

[ronakvora do not use, 2014/08/05 19:54:49]

Don't. Removed!

+  core_->EnableWindowInjection(window_id_input_injector_mac_);
+}
+
 InputInjectorMac::Core::Core(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : task_runner_(task_runner),
       mouse_button_state_(0),
       clipboard_(Clipboard::Create()),
       left_modifiers_(0),
       right_modifiers_(0) {
   // Ensure that local hardware events are not suppressed after injecting
   // input events.  This allows LocalInputMonitor to detect if the local mouse
   // is being moved whilst a remote user is connected.
   // This API is deprecated, but it is needed when using the deprecated
   // injection APIs.
   // If the non-deprecated injection APIs were used instead, the equivalent of
   // this line would not be needed, as OS X defaults to _not_ suppressing local
   // inputs in that case.
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdeprecated-declarations"
   CGSetLocalEventsSuppressionInterval(0.0);
 #pragma clang diagnostic pop
 }
 
+void InputInjectorMac::Core::EnableWindowInjection(CGWindowID window_id) {
+  window_id_core_ = window_id;
+  window_injection_enabled_ = true;
+}
+
 void InputInjectorMac::Core::InjectClipboardEvent(const ClipboardEvent& event) {
   if (!task_runner_->BelongsToCurrentThread()) {
     task_runner_->PostTask(
         FROM_HERE, base::Bind(&Core::InjectClipboardEvent, this, event));
     return;
   }
 
   // |clipboard_| will ignore unknown MIME-types, and verify the data's format.
   clipboard_->InjectClipboardEvent(event);
 }
@@ skipping 45 matching lines @@
 void InputInjectorMac::Core::InjectTextEvent(const TextEvent& event) {
   DCHECK(event.has_text());
   base::string16 text = base::UTF8ToUTF16(event.text());
 
   // Applications that ignore UnicodeString field will see the text event as
   // Space key.
   CreateAndPostKeyEvent(kVK_Space, true, 0, text);
   CreateAndPostKeyEvent(kVK_Space, false, 0, text);
 }
 
+// This method is used if we are capturing a window instead of a screen.
+// It finds the rectangle of the window we are streaming using
+// |window_id_core_|. The InputInjector can then use this rectangle
+// to translate the input event to coordinates of the window rather
+// than the screen.
+CGRect InputInjectorMac::Core::FindCGRectOfWindow(
+  webrtc::MacDesktopConfiguration desktop_config) {
+  CGRect rect;
+  CGWindowID ids[1] = {window_id_core_};
+  CFArrayRef window_id_array =
+      CFArrayCreate(NULL, reinterpret_cast<const void **>(&ids), 1, NULL);
+  CFArrayRef window_array =
+      CGWindowListCreateDescriptionFromArray(window_id_array);
+  if (window_array == NULL || 0 == CFArrayGetCount(window_array)) {
+    // Could not find the window. It might have been closed.
+    LOG(ERROR) << "Specified window to stream not found for id: "
+               << window_id_core_;
+    CFRelease(window_id_array);
+    CFRelease(window_array);
+    return CGRectNull;
+  }
+  CFDictionaryRef window = reinterpret_cast<CFDictionaryRef>(
+      CFArrayGetValueAtIndex(window_array, 0));
+
+  if (CFDictionaryContainsKey(window, kCGWindowBounds)) {
+    CFDictionaryRef bounds =
+        reinterpret_cast<CFDictionaryRef>
+            (CFDictionaryGetValue(window, kCGWindowBounds));
+    if (bounds) {
+      CGRectMakeWithDictionaryRepresentation(bounds, &rect);
+    }
+  }
+
+  CFRelease(window_id_array);
+  CFRelease(window_array);
+  return rect;
+}
+
 void InputInjectorMac::Core::InjectMouseEvent(const MouseEvent& event) {
   if (event.has_x() && event.has_y()) {
     // On multi-monitor systems (0,0) refers to the top-left of the "main"
     // display, whereas our coordinate scheme places (0,0) at the top-left of
     // the bounding rectangle around all the displays, so we need to translate
     // accordingly.
 
     // Set the mouse position assuming single-monitor.
     mouse_pos_.set(event.x(), event.y());
 
@@ skipping 15 matching lines @@
     mouse_pos_.set(
        std::max(desktop_config.pixel_bounds.left(),
            std::min(desktop_config.pixel_bounds.right(), mouse_pos_.x())),
        std::max(desktop_config.pixel_bounds.top(),
            std::min(desktop_config.pixel_bounds.bottom(), mouse_pos_.y())));
 
     // Convert from pixel to Density Independent Pixel coordinates.
     mouse_pos_.set(mouse_pos_.x() / desktop_config.dip_to_pixel_scale,
                    mouse_pos_.y() / desktop_config.dip_to_pixel_scale);
 
+    if (window_injection_enabled_) {
+      CGRect windowRect = FindCGRectOfWindow(desktop_config);
+      if (CGRectEqualToRect(windowRect, CGRectNull)) {
+        LOG(ERROR) << "Can't find rectangle of window.";
+        return;
+      }
+      mouse_pos_ = mouse_pos_.add(
+          webrtc::DesktopVector(CGRectGetMinX(windowRect),
+                                CGRectGetMinY(windowRect)));

[Wez, 2014/08/01 23:41:54]

Do you mean to clamp input to the window width & height as well?

What happens if the window is resized on the host, mid-session?

[ronakvora do not use, 2014/08/05 19:54:49]

I don't know what you mean by clamp input to window width & height. What I'm
trying to do is basically adjust for the fact that the the host receives
coordinates in respect to the entire desktop rather than the window. I do this
by calculating the top-left of the window we are capturing and adding those
coordinates to the coordinates sent to the host from the client (which, again,
are in respect to the desktop). This way the events are injected to the correct
place on the host side (correct place = place on the window we are capturing
that the user clicked on in the client).

If the window gets resized, that is fine because I call FindCGRectOfWindow()
before adjusting every time (right under the if (window_injection_enabled_)
statement.

+    }
+
     VLOG(3) << "Moving mouse to " << mouse_pos_.x() << "," << mouse_pos_.y();
   }
   if (event.has_button() && event.has_button_down()) {
     if (event.button() >= 1 && event.button() <= 3) {
       VLOG(2) << "Button " << event.button()
               << (event.button_down() ? " down" : " up");
       int button_change = 1 << (event.button() - 1);
       if (event.button_down())
         mouse_button_state_ |= button_change;
       else
@@ skipping 58 matching lines @@
 InputInjectorMac::Core::~Core() {}
 
 }  // namespace
 
 scoped_ptr<InputInjector> InputInjector::Create(
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner) {
   return scoped_ptr<InputInjector>(new InputInjectorMac(main_task_runner));
 }
 
+scoped_ptr<InputInjector> InputInjector::CreateForWindow(
+      scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
+      scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
+      webrtc::WindowId window_id) {
+  scoped_ptr<InputInjectorMac>injector(new InputInjectorMac(main_task_runner));
+  injector->EnableWindowInjection(window_id);
+  return injector.PassAs<InputInjector>();
+}
+
 }  // namespace remoting