Clean up remoting project

remoting/host/event_executor_win.cc

 // Copyright (c) 2010 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/event_executor_win.h"
+#include "remoting/host/event_executor.h"
 
 #include <windows.h>
 
+#include "base/compiler_specific.h"
 #include "base/message_loop.h"
-#include "base/stl_util-inl.h"
 #include "remoting/host/capturer.h"
 #include "remoting/proto/event.pb.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 
 namespace remoting {
 
 using protocol::MouseEvent;
 using protocol::KeyEvent;
 
-EventExecutorWin::EventExecutorWin(
-    MessageLoopForUI* message_loop, Capturer* capturer)
+namespace {
+
+// A class to generate events on Windows.
+class EventExecutorWin : public EventExecutor {
+ public:
+  EventExecutorWin(MessageLoopForUI* message_loop, Capturer* capturer);
+  virtual ~EventExecutorWin() {}
+
+  virtual void InjectKeyEvent(const KeyEvent* event, Task* done) OVERRIDE;
+  virtual void InjectMouseEvent(const MouseEvent* event, Task* done) OVERRIDE;
+
+ private:
+  void HandleKey(const KeyEvent* event);
+  void HandleMouse(const MouseEvent* event);
+
+  MessageLoopForUI* message_loop_;
+  Capturer* capturer_;
+
+  DISALLOW_COPY_AND_ASSIGN(EventExecutorWin);
+};
+
+EventExecutorWin::EventExecutorWin(MessageLoopForUI* message_loop,
+                                   Capturer* capturer)
     : message_loop_(message_loop),
       capturer_(capturer) {
 }
 
-EventExecutorWin::~EventExecutorWin() {
-}
-
 void EventExecutorWin::InjectKeyEvent(const KeyEvent* event, Task* done) {
   if (MessageLoop::current() != message_loop_) {
     message_loop_->PostTask(
         FROM_HERE,
         NewRunnableMethod(this, &EventExecutorWin::InjectKeyEvent,
                           event, done));
     return;
   }
   HandleKey(event);
   done->Run();
@@ skipping 36 matching lines @@
   }
 
   // Flag to mark keyup events. Default is keydown.
   if (!down) {
     input.ki.dwFlags |= KEYEVENTF_KEYUP;
   }
 
   SendInput(1, &input, sizeof(INPUT));
 }
 
-protocol::InputStub* CreateEventExecutor(MessageLoopForUI* message_loop,
-                                         Capturer* capturer) {
-  return new EventExecutorWin(message_loop, capturer);
-}
-
 void EventExecutorWin::HandleMouse(const MouseEvent* event) {
   // TODO(garykac) Collapse mouse (x,y) and button events into a single
   // input event when possible.
   if (event->has_x() && event->has_y()) {
     int x = event->x();
     int y = event->y();
 
     INPUT input;
     input.type = INPUT_MOUSE;
     input.mi.time = 0;
@@ skipping 46 matching lines @@
           down ? MOUSEEVENTF_RIGHTDOWN : MOUSEEVENTF_RIGHTUP;
     } else {
       button_event.mi.dwFlags =
           down ? MOUSEEVENTF_LEFTDOWN : MOUSEEVENTF_LEFTUP;
     }
 
     SendInput(1, &button_event, sizeof(INPUT));
   }
 }
 
+}  // namespace
+
+EventExecutor* EventExecutor::Create(MessageLoopForUI* message_loop,
+                                     Capturer* capturer) {
+  return new EventExecutorWin(message_loop, capturer);
+}
+
 }  // namespace remoting
+
+DISABLE_RUNNABLE_METHOD_REFCOUNT(remoting::EventExecutorWin);
+