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;
+  // TODO(sidj, sskhandp) Remove these methods and use
+  // WindowInputInjectorMac instead.
+  virtual void SetWindowId(webrtc::WindowId windowId);

[Lambros, 2014/07/30 00:14:48]

Do these need to be virtual?

[ronakvora do not use, 2014/07/30 20:55:36]

Nope, changed.

+  virtual void SetEnableWindowCapture(bool enable_window_capture);

[Lambros, 2014/07/30 00:14:48]

Don't say "Capture" here. Maybe replace these methods with a single method
called EnableWindowInjection(webrtc::WindowId window_id)
or similar?

You could maybe add this method to the InputInjector interface, and make it a
no-op with NOTIMPLEMENTED() in the Windows and Linux implementations?

[ronakvora do not use, 2014/07/30 20:55:36]

Done.

 
  private:
+  // TODO(sidj, sskhandp) put these inside of WindowInputInjectorMac.

[Lambros, 2014/07/30 00:14:49]

Remove TODO - I don't think it's worth defining a separate class for this. It
should be a simple modification to the existing classes to support per-window
injection on each platform.

[ronakvora do not use, 2014/07/30 20:55:36]

Done.

+  CGWindowID windowId_input_injector_mac_;

[Lambros, 2014/07/30 00:14:49]

nit: window_id_

[ronakvora do not use, 2014/07/30 20:55:36]

Done.

+  bool enable_window_capture_injector_mac_;

[Lambros, 2014/07/30 00:14:48]

nit: window_injection_enabled_ - don't use "capture" or "mac". And field names
should be nouns, not verbs.

[ronakvora do not use, 2014/07/30 20:55:36]

Done.

   // 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);
 
+    // TODO(sidj, sskhandp) Remove these methods and use

[Lambros, 2014/07/30 00:14:48]

Remove TODO.

[ronakvora do not use, 2014/07/30 20:55:36]

Done.

+    // WindowInputInjectorMac instead.
+    void SetWindowId(CGWindowID windowId);
+    void SetEnableWindowCapture(bool enable_window_capture);
+
     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_;
+    // TODO(sidj, sskhandp) put these inside of WindowInputInjectorMac.

[Lambros, 2014/07/30 00:14:48]

Remove TODO.

[ronakvora do not use, 2014/07/30 20:55:36]

Done.

+    CGWindowID windowId_core_;
+    bool enable_window_capture_core_;
 
     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::SetWindowId(webrtc::WindowId windowId) {
+  windowId_input_injector_mac_ = (CGWindowID) windowId;
+  core_->SetWindowId(windowId_input_injector_mac_);
+}
+
+void InputInjectorMac::SetEnableWindowCapture(bool enable_window_capture) {
+  enable_window_capture_injector_mac_ = enable_window_capture;
+  core_->SetEnableWindowCapture(enable_window_capture_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::SetWindowId(CGWindowID windowId) {
+  windowId_core_ = windowId;
+}
+void InputInjectorMac::Core::SetEnableWindowCapture
+    (bool enable_window_capture) {
+  enable_window_capture_core_ = enable_window_capture;
+}
 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);
 }
 
+CGRect InputInjectorMac::Core::FindCGRectOfWindow(
+  webrtc::MacDesktopConfiguration desktop_config) {
+  CGRect rect;
+  CGWindowID ids[1] = {windowId_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: "
+               << windowId_core_;
+    CFRelease(window_id_array);

[Lambros, 2014/07/30 00:14:49]

Use ScopedCFTypeRef from base/mac/scoped_cftyperef.h instead of manually calling
CFRelease here.

[ronakvora do not use, 2014/07/30 20:55:36]

I've been a bit confused on the scoped_X types. Do these types take care of the
releasing and retaining for me?

+    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);
 
+    // Translate the mouse position into window coordinates.
+    // TODO(sskhandp, sidj) Remove this if clause and implement
+    // functionality in WindowInputInjectorMac.
+    if (enable_window_capture_core_) {
+      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)));
+    }
+
     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));
 }
 
+// TODO(sskhandp, sidj) remove this method and make WindowInputInjector

[Lambros, 2014/07/30 00:14:48]

Remove TODO.

[ronakvora do not use, 2014/07/30 20:55:36]

Done.

+scoped_ptr<InputInjector> InputInjector::Create(
+      scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
+      scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
+      webrtc::WindowId windowId,
+      bool enable_window_capture) {
+  InputInjectorMac* injector = new InputInjectorMac(main_task_runner);

[Lambros, 2014/07/30 00:14:49]

nit: Declare |injector| as scoped_ptr instead of raw pointer. If you want, you
could use the existing Create() method here.

[ronakvora do not use, 2014/07/30 20:55:36]

Done.

+  injector->SetWindowId(windowId);
+  injector->SetEnableWindowCapture(enable_window_capture);
+  return scoped_ptr<InputInjector>(injector);
+}
+
 }  // namespace remoting