Add base/android/activity_status.cc

base/android/activity_status_unittest.cc

Index: base/android/activity_status_unittest.cc
diff --git a/base/android/activity_status_unittest.cc b/base/android/activity_status_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..f8f08e24c5fdbf891618ab598ad123c51a3c78e2
--- /dev/null
+++ b/base/android/activity_status_unittest.cc
@@ -0,0 +1,176 @@
+// Copyright 2013 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 "base/android/activity_status.h"
+#include "base/android/jni_android.h"
+#include "base/bind.h"
+#include "base/callback_forward.h"
+#include "base/logging.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/message_loop/message_loop_proxy.h"
+#include "base/run_loop.h"
+#include "base/synchronization/waitable_event.h"
+#include "base/threading/thread.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace base {
+namespace android {
+
+// This is equivalent to what the JNI generator would output if
+// ActivityStatus.onStateChange() was tagged with @CalledByNative.
+// because this is only useful for unit-testing, there is no point in
+// making this permanent for production code.
+using base::android::ScopedJavaLocalRef;
+
+namespace {
+
+const char kActivityStatusClassPath[] = "org/chromium/base/ActivityStatus";
+jclass g_ActivityStatus_clazz = NULL;
+
+base::subtle::AtomicWord g_ActivityStatus_onStateChange = 0;
+
+void Java_ActivityStatus_onStateChange(JNIEnv* env,
+                                       jobject activity,
+                                       jint newState) {
+  // Ensure g_ActivityStatus_clazz is initialized
+  if (g_ActivityStatus_clazz == NULL) {
+    g_ActivityStatus_clazz = reinterpret_cast<jclass>(env->NewGlobalRef(
+        base::android::GetClass(env, kActivityStatusClassPath).obj()));
+    DCHECK(g_ActivityStatus_clazz);
+  }
+  jmethodID method_id =
+      base::android::MethodID::LazyGet<
+      base::android::MethodID::TYPE_STATIC>(
+      env, g_ActivityStatus_clazz,
+      "onStateChange",
+      "("
+      "Landroid/app/Activity;"
+      "I"
+      ")"
+      "V",
+      &g_ActivityStatus_onStateChange);
+
+  env->CallStaticVoidMethod(g_ActivityStatus_clazz,
+      method_id, activity, newState);
+  base::android::CheckException(env);
+}
+
+void ForceActivityStateTo(ActivityState state) {
+  JNIEnv* env = base::android::AttachCurrentThread();
+  ASSERT_TRUE(env);
+  RunLoop run_loop;
+  Java_ActivityStatus_onStateChange(env, NULL, static_cast<int>(state));
+  run_loop.RunUntilIdle();
+}
+
+// Used to generate a callback that stores the new state at a given
+// location.
+void StoreStateTo(ActivityState* target, ActivityState state) {
+  *target = state;
+}
+
+// An invalid ActivityState value.
+const ActivityState kInvalidActivityState = static_cast<ActivityState>(100);
+
+// Shared state for the multi-threaded test.
+// This uses a thread to register for events and listen to them,
+// while state changes are forced on the main thread.
+class MultiThreadedTest
+  : public base::RefCountedThreadSafe<MultiThreadedTest> {
+public:
+  MultiThreadedTest()
+    : state_(kInvalidActivityState),
+      event_(false, false),
+      thread_("ActivityStatusTest thread"),
+      main_(),
+      listener_(NULL) {
+  }
+
+  void Run() {
+    RunLoop loop;
+
+    // Start the thread and tell it to register for events.
+    thread_.Start();
+    thread_.message_loop()->PostTask(
+        FROM_HERE,
+        base::Bind(&MultiThreadedTest::RegisterThreadForEvents, this));
+
+    // Wait for its completion.
+    event_.Wait();
+
+    // Change state, then wait for the thread to modify state.
+    ForceActivityStateTo(ACTIVITY_STATE_CREATED);
+    event_.Wait();
+    EXPECT_EQ(ACTIVITY_STATE_CREATED, state_);
+
+    // Again
+    ForceActivityStateTo(ACTIVITY_STATE_DESTROYED);
+    event_.Wait();
+    EXPECT_EQ(ACTIVITY_STATE_DESTROYED, state_);
+  }
+
+private:
+  virtual ~MultiThreadedTest() {}
+
+  void AssertOnThread() {
+    ASSERT_EQ(thread_.message_loop(),
+              base::MessageLoop::current());
+  }
+
+  void RegisterThreadForEvents() {
+    AssertOnThread();
+    listener_.reset(
+        new ActivityStatus::Listener(
+            base::Bind(&MultiThreadedTest::StoreStateAndSignal, this)));
+    ASSERT_TRUE(listener_.get());
+    event_.Signal();
+  }
+
+  void StoreStateAndSignal(ActivityState state) {
+    AssertOnThread();
+    state_ = state;
+    event_.Signal();
+  }
+
+  friend class base::RefCountedThreadSafe<MultiThreadedTest>;
+
+  ActivityState state_;
+  base::WaitableEvent event_;
+  base::Thread thread_;
+  base::MessageLoop main_;
+  scoped_ptr<ActivityStatus::Listener> listener_;
+};
+
+}  // namespace
+
+TEST(ActivityStatusTest, SingleThread) {
+  MessageLoop message_loop;
+
+  ActivityState result = kInvalidActivityState;
+
+  // Create a new listener that stores the new state into |result|
+  // on every state change.
+  scoped_ptr<ActivityStatus::Listener> listener(
+      new ActivityStatus::Listener(
+          base::Bind(&StoreStateTo, base::Unretained(&result))));
+  ASSERT_TRUE(listener.get());
+
+  EXPECT_EQ(kInvalidActivityState, result);
+
+  ForceActivityStateTo(ACTIVITY_STATE_CREATED);
+  EXPECT_EQ(ACTIVITY_STATE_CREATED, result);
+
+  ForceActivityStateTo(ACTIVITY_STATE_DESTROYED);
+  EXPECT_EQ(ACTIVITY_STATE_DESTROYED, result);
+}
+
+TEST(ActivityStatusTest, TwoThreads) {
+  scoped_refptr<MultiThreadedTest> test(new MultiThreadedTest());
+  test->Run();
+}
+
+}  // namespace android
+}  // namespace base