[NaCl SDK] Cleanup examples.

native_client_sdk/src/examples/api/input_event/input_event.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.
 
 // C headers
 #include <cassert>
 #include <cstdio>
 
 // C++ headers
 #include <sstream>
 #include <string>
 
 // PPAPI headers
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/cpp/input_event.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/point.h"
 #include "ppapi/cpp/var.h"
 #include "ppapi/utility/completion_callback_factory.h"
 
 #include "custom_events.h"
 #include "shared_queue.h"
 
 #ifdef PostMessage
 #undef PostMessage
 #endif
 
-namespace event_queue {
 const char* const kDidChangeView = "DidChangeView\n";
 const char* const kHandleInputEvent = "DidHandleInputEvent\n";
 const char* const kDidChangeFocus = "DidChangeFocus\n";
 const char* const kHaveFocus = "HaveFocus\n";
 const char* const kDontHaveFocus = "DontHaveFocus\n";
 const char* const kCancelMessage = "CANCEL";
 
 // Convert a pepper inputevent modifier value into a
 // custom event modifier.
 unsigned int ConvertEventModifier(uint32_t pp_modifier) {
@@ skipping 27 matching lines @@
   }
   if (pp_modifier & PP_INPUTEVENT_MODIFIER_CAPSLOCKKEY) {
     custom_modifier |= kCapsLockModifier;
   }
   if (pp_modifier & PP_INPUTEVENT_MODIFIER_NUMLOCKKEY) {
     custom_modifier |= kNumLockModifier;
   }
   return custom_modifier;
 }
 
-class EventInstance : public pp::Instance {
+class InputEventInstance : public pp::Instance {
  public:
-  explicit EventInstance(PP_Instance instance)
+  explicit InputEventInstance(PP_Instance instance)
       : pp::Instance(instance), event_thread_(NULL), callback_factory_(this) {
     RequestInputEvents(PP_INPUTEVENT_CLASS_MOUSE | PP_INPUTEVENT_CLASS_WHEEL |
                        PP_INPUTEVENT_CLASS_TOUCH);
     RequestFilteringInputEvents(PP_INPUTEVENT_CLASS_KEYBOARD);
   }
 
   // Not guaranteed to be called in Pepper, but a good idea to cancel the
   // queue and signal to workers to die if it is called.
-  virtual ~EventInstance() { CancelQueueAndWaitForWorker(); }
+  virtual ~InputEventInstance() { CancelQueueAndWaitForWorker(); }
 
   // Create the 'worker thread'.
   bool Init(uint32_t argc, const char* argn[], const char* argv[]) {
     event_thread_ = new pthread_t;
     pthread_create(event_thread_, NULL, ProcessEventOnWorkerThread, this);
     return true;
   }
 
   /// Clicking outside of the instance's bounding box
   /// will create a DidChangeFocus event (the NaCl instance is
   /// out of focus). Clicking back inside the instance's
   /// bounding box will create another DidChangeFocus event
   /// (the NaCl instance is back in focus). The default is
   /// that the instance is out of focus.
   void DidChangeFocus(bool focus) {
     PostMessage(pp::Var(kDidChangeFocus));
     if (focus == true) {
       PostMessage(pp::Var(kHaveFocus));
     } else {
       PostMessage(pp::Var(kDontHaveFocus));
     }
   }
 
   /// Scrolling the mouse wheel causes a DidChangeView event.
   void DidChangeView(const pp::View& view) {
     PostMessage(pp::Var(kDidChangeView));
   }
 
-  /// Called by the browser to handle the postMessage() call in Javascript.
-  /// Detects which method is being called from the message contents, and
-  /// calls the appropriate function.  Posts the result back to the browser
-  /// asynchronously.
-  /// @param[in] var_message The message posted by the browser.  The only
-  ///     supported message is |kCancelMessage|.  If we receive this, we
-  ///     cancel the shared queue.
   virtual void HandleMessage(const pp::Var& var_message) {
     std::string message = var_message.AsString();
     if (kCancelMessage == message) {
       std::string reply =
           "Received cancel : only Focus events will be "
           "displayed. Worker thread for mouse/wheel/keyboard will exit.";
       PostMessage(pp::Var(reply));
       printf("Calling cancel queue\n");
       CancelQueueAndWaitForWorker();
     }
@@ skipping 140 matching lines @@
     PostMessage(pp::Var(data_to_send));
     return 0;
   }
 
   // |ProcessEventOnWorkerThread| is a static method that is run
   // by a thread.  It pulls events from the queue, converts
   // them to a string, and calls CallOnMainThread so that
   // PostStringToBrowser will be called, which will call PostMessage
   // to send the converted event back to the browser.
   static void* ProcessEventOnWorkerThread(void* param) {
-    EventInstance* event_instance = static_cast<EventInstance*>(param);
+    InputEventInstance* event_instance =
+        static_cast<InputEventInstance*>(param);
     while (1) {
       // Grab a generic Event* so that down below we can call
       // event->ToString(), which will use the correct virtual method
       // to convert the event to a string.  This 'conversion' is
       // the 'work' being done on the worker thread.  In an application
       // the work might involve changing application state based on
       // the event that was processed.
       bool queue_cancelled;
       const Event* event = event_instance->GetEventFromQueue(&queue_cancelled);
       if (queue_cancelled) {
         printf("Queue was cancelled, worker thread exiting\n");
         pthread_exit(NULL);
       }
       std::string event_string = event->ToString();
       delete event;
       // Need to invoke callback on main thread.
       pp::Module::Get()->core()->CallOnMainThread(
           0,
-          event_instance->callback_factory()
-              .NewCallback(&EventInstance::PostStringToBrowser, event_string));
+          event_instance->callback_factory().NewCallback(
+              &InputEventInstance::PostStringToBrowser, event_string));
     }  // end of while loop.
     return 0;
   }
 
   // Return the callback factory.
   // Allows the static method (ProcessEventOnWorkerThread) to use
   // the |event_instance| pointer to get the factory.
-  pp::CompletionCallbackFactory<EventInstance>& callback_factory() {
+  pp::CompletionCallbackFactory<InputEventInstance>& callback_factory() {
     return callback_factory_;
   }
 
  private:
   // Cancels the queue (which will cause the thread to exit).
   // Wait for the thread.  Set |event_thread_| to NULL so we only
   // execute the body once.
   void CancelQueueAndWaitForWorker() {
     if (event_thread_) {
       event_queue_.CancelQueue();
       pthread_join(*event_thread_, NULL);
       delete event_thread_;
       event_thread_ = NULL;
     }
   }
   pthread_t* event_thread_;
   LockingQueue<Event*> event_queue_;
-  pp::CompletionCallbackFactory<EventInstance> callback_factory_;
+  pp::CompletionCallbackFactory<InputEventInstance> callback_factory_;
 };
 
-// The EventModule provides an implementation of pp::Module that creates
-// EventInstance objects when invoked.  This is part of the glue code that makes
-// our example accessible to ppapi.
-class EventModule : public pp::Module {
+class InputEventModule : public pp::Module {
  public:
-  EventModule() : pp::Module() {}
-  virtual ~EventModule() {}
+  InputEventModule() : pp::Module() {}
+  virtual ~InputEventModule() {}
 
   virtual pp::Instance* CreateInstance(PP_Instance instance) {
-    return new EventInstance(instance);
+    return new InputEventInstance(instance);
   }
 };
 
-}  // namespace
-
-// Implement the required pp::CreateModule function that creates our specific
-// kind of Module (in this case, EventModule).  This is part of the glue code
-// that makes our example accessible to ppapi.
 namespace pp {
-Module* CreateModule() { return new event_queue::EventModule(); }
+Module* CreateModule() { return new InputEventModule(); }
 }