Refactor ActivityStatus to not store current activity

base/android/activity_status.h

 // 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.
 
 #ifndef BASE_ANDROID_ACTIVITY_STATUS_H_
 #define BASE_ANDROID_ACTIVITY_STATUS_H_
 
 #include <jni.h>
 
 #include "base/android/jni_android.h"
 #include "base/base_export.h"
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/singleton.h"
 #include "base/observer_list_threadsafe.h"
 
 namespace base {
 namespace android {
 
-// Define activity state values like ACTIVITY_STATE_CREATED in a
+// Define activity state values like APPLICATION_STATE_VISIBLE in a
 // way that ensures they're always the same than their Java counterpart.
-enum ActivityState {
-#define DEFINE_ACTIVITY_STATE(x, y) ACTIVITY_STATE_##x = y,
-#include "base/android/activity_state_list.h"
-#undef DEFINE_ACTIVITY_STATE
+enum ApplicationState {
+#define DEFINE_APPLICATION_STATE(x, y) APPLICATION_STATE_##x = y,
+#include "base/android/application_state_list.h"
+#undef DEFINE_APPLICATION_STATE
 };
 
-// A native helper class to listen to state changes of the current
-// Android Activity. This mirrors org.chromium.base.ActivityStatus.
+// A native helper class to listen to state changes of the Android
+// Application. This mirrors org.chromium.base.ActivityStatus.
 // any thread.
 //
 // To start listening, create a new instance, passing a callback to a
-// function that takes an ActivityState parameter. To stop listening,
+// function that takes two boolean parameters. To stop listening,
 // simply delete the listener object. The implementation guarantees
 // that the callback will always be called on the thread that created
 // the listener.
 //
 // Example:
 //
-//    void OnActivityStateChange(ActivityState state) {
+//    void OnApplicationStateChange(bool foreground, bool active) {

[Ted C, 2014/02/13 04:38:44]

update since it's no longer two booleans

same in the above comment

[David Trainor- moved to gerrit, 2014/02/14 19:13:36]

Done.

 //       ...
 //    }
 //
 //    // Start listening.
 //    ActivityStatus::Listener* my_listener =
-//        new ActivityStatus::Listener(base::Bind(&OnActivityStateChange));
+//        new ActivityStatus::Listener(base::Bind(&OnApplicationStateChange));
 //
 //    ...
 //
 //    // Stop listening.
 //    delete my_listener
 //
 class BASE_EXPORT ActivityStatus {

[Ted C, 2014/02/13 04:38:44]

This should probably be called ApplicationStatus, but I guess I don't want to
rock the boat too much.

[bulach, 2014/02/13 11:17:48]

yes, ApplicationStatus please :)
imho, either:
- keep the ActivityStatus temporarily whilst introducing the new
ApplicationState (i.e., N-side patches) 
- go all the way and rename this class, this file and its tests (which I'd
prefer!).


while at it... when we implemented the MemoryPressureListener:
https://code.google.com/p/chromium/codesearch#chromium/src/base/memory/memory...

we changed the relationship slightly:
rather than having these inner-listener notified by an outer singleton, there's
only one "public" level for listeners and the singleton became an internal
detail just in the .cc...

since we'll have to change everything ;) perhaps this would be a good time?

  public:
-  typedef base::Callback<void(ActivityState)> StateChangeCallback;
+  typedef base::Callback<void(ApplicationState)> ApplicationStateChangeCallback;
 
   class Listener {
    public:
-    explicit Listener(const StateChangeCallback& callback);
+    explicit Listener(const ApplicationStateChangeCallback& callback);
     ~Listener();
 
    private:
     friend class ActivityStatus;
 
-    void Notify(ActivityState state);
+    void Notify(ApplicationState state);
 
-    StateChangeCallback callback_;
+    ApplicationStateChangeCallback callback_;
 
     DISALLOW_COPY_AND_ASSIGN(Listener);
   };
 
   // NOTE: The Java ActivityStatus is a singleton too.
   static ActivityStatus* GetInstance();
 
   // Internal use: must be public to be called from base_jni_registrar.cc
   static bool RegisterBindings(JNIEnv* env);
 
   // Internal use only: must be public to be called from JNI and unit tests.
-  void OnActivityStateChange(ActivityState new_state);
+  void OnApplicationStateChange(ApplicationState state);
 
  private:
   friend struct DefaultSingletonTraits<ActivityStatus>;
 
   ActivityStatus();
   ~ActivityStatus();
 
   void RegisterListener(Listener* listener);
   void UnregisterListener(Listener* listener);
 
   scoped_refptr<ObserverListThreadSafe<Listener> > observers_;
 
   DISALLOW_COPY_AND_ASSIGN(ActivityStatus);
 };
 
 }  // namespace android
 }  // namespace base
 
 #endif  // BASE_ANDROID_ACTIVITY_STATUS_H_