Android's paths and message loop implementation with JNI

base/message_loop.h

 // Copyright (c) 2011 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.
 
 #ifndef BASE_MESSAGE_LOOP_H_
 #define BASE_MESSAGE_LOOP_H_
 #pragma once
 
 #include <queue>
 #include <string>
@@ skipping 97 matching lines @@
   // Normally, it is not necessary to instantiate a MessageLoop.  Instead, it
   // is typical to make use of the current thread's MessageLoop instance.
   explicit MessageLoop(Type type = TYPE_DEFAULT);
   virtual ~MessageLoop();
 
   // Returns the MessageLoop object for the current thread, or null if none.
   static MessageLoop* current();
 
   static void EnableHistogrammer(bool enable_histogrammer);
 
+  typedef base::MessagePump* (MessagePumpFactory)();
+  // Using the given base::MessagePumpForUIFactory to override the default

[M-A Ruel, 2011/11/11 13:09:07]

Can you use an action sentence instead?

+  // MessagePump implementation for 'TYPE_UI'.
+  static void InitMessagePumpForUIFactory(MessagePumpFactory* factory);
+
   // A DestructionObserver is notified when the current MessageLoop is being
   // destroyed.  These obsevers are notified prior to MessageLoop::current()
   // being changed to return NULL.  This gives interested parties the chance to
   // do final cleanup that depends on the MessageLoop.
   //
   // NOTE: Any tasks posted to the MessageLoop during this notification will
   // not be run.  Instead, they will be deleted.
   //
   class BASE_API DestructionObserver {
    public:
@@ skipping 233 matching lines @@
   //----------------------------------------------------------------------------
  protected:
   struct RunState {
     // Used to count how many Run() invocations are on the stack.
     int run_depth;
 
     // Used to record that Quit() was called, or that we should quit the pump
     // once it becomes idle.
     bool quit_received;
 
-#if !defined(OS_MACOSX)
+#if !defined(OS_MACOSX) && !defined(OS_ANDROID)
     Dispatcher* dispatcher;
 #endif
   };
 
+#if defined(OS_ANDROID)
+  // Android Java process manages the UI thread message loop. So its
+  // MessagePumpForUI needs to keep the RunState.
+ public:
+#endif
   class BASE_API AutoRunState : RunState {
    public:
     explicit AutoRunState(MessageLoop* loop);
     ~AutoRunState();
    private:
     MessageLoop* loop_;
     RunState* previous_state_;
   };
+#if defined(OS_ANDROID)
+ protected:
+#endif
 
   // This structure is copied around by value.
   struct PendingTask {
     PendingTask(const base::Closure& task,
                 const tracked_objects::Location& posted_from,
                 base::TimeTicks delayed_run_time,
                 bool nestable);
     ~PendingTask();
 
     // Used to support sorting.
@@ skipping 182 matching lines @@
   static MessageLoopForUI* current() {
     MessageLoop* loop = MessageLoop::current();
     DCHECK_EQ(MessageLoop::TYPE_UI, loop->type());
     return static_cast<MessageLoopForUI*>(loop);
   }
 
 #if defined(OS_WIN)
   void DidProcessMessage(const MSG& message);
 #endif  // defined(OS_WIN)
 
-#if !defined(OS_MACOSX)
+#if defined(OS_ANDROID)
+  // On Android, the UI message loop is handled by Java side. So Run() should
+  // never be called. Instead use Start(), which will forward all the native UI
+  // events to the Java message loop.
+  void Start();
+#elif !defined(OS_MACOSX)
   // Please see message_pump_win/message_pump_glib for definitions of these
   // methods.
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
   void Run(Dispatcher* dispatcher);
 
  protected:
   // TODO(rvargas): Make this platform independent.
   base::MessagePumpForUI* pump_ui() {
     return static_cast<base::MessagePumpForUI*>(pump_.get());
@@ skipping 78 matching lines @@
 #endif  // defined(OS_POSIX)
 };
 
 // Do not add any member variables to MessageLoopForIO!  This is important b/c
 // MessageLoopForIO is often allocated via MessageLoop(TYPE_IO).  Any extra
 // data that you need should be stored on the MessageLoop's pump_ instance.
 COMPILE_ASSERT(sizeof(MessageLoop) == sizeof(MessageLoopForIO),
                MessageLoopForIO_should_not_have_extra_member_variables);
 
 #endif  // BASE_MESSAGE_LOOP_H_