[Android] Make ApplicationStatus thread safe

base/android/java/src/org/chromium/base/ApplicationStatus.java

 // Copyright 2014 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.
 
 package org.chromium.base;
 
 import android.app.Activity;
 import android.app.Application;
 import android.app.Application.ActivityLifecycleCallbacks;
 import android.content.Context;
 import android.os.Bundle;
 
 import java.lang.ref.WeakReference;
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * Provides information about the current activity's status, and a way
  * to register / unregister listeners for state changes.
  */
 @JNINamespace("base::android")
 public class ApplicationStatus {
     private static class ActivityInfo {
         private int mStatus = ActivityState.DESTROYED;
         private ObserverList<ActivityStateListener> mListeners =
@@ skipping 16 matching lines @@
         /**
          * @return A list of {@link ActivityStateListener}s listening to this activity.
          */
         public ObserverList<ActivityStateListener> getListeners() {
             return mListeners;
         }
     }
 
     private static Application sApplication;
 
+    private static Object sCachedApplicationStateLock = new Object();
     private static Integer sCachedApplicationState;
 
     /** Last activity that was shown (or null if none or it was destroyed). */
     private static Activity sActivity;
 
     /** A lazily initialized listener that forwards application state changes to native. */
     private static ApplicationStateListener sNativeApplicationStateListener;
 
     /**
      * A map of which observers listen to state changes from which {@link Activity}.
      */
     private static final Map<Activity, ActivityInfo> sActivityInfo =
-            new HashMap<Activity, ActivityInfo>();
+            new ConcurrentHashMap<Activity, ActivityInfo>();
 
     /**
      * A list of observers to be notified when any {@link Activity} has a state change.
      */
     private static final ObserverList<ActivityStateListener> sGeneralActivityStateListeners =
             new ObserverList<ActivityStateListener>();
 
     /**
      * A list of observers to be notified when the visibility state of this {@link Application}
      * changes.  See {@link #getStateForApplication()}.
@@ skipping 103 matching lines @@
         }
 
         int oldApplicationState = getStateForApplication();
 
         if (newState == ActivityState.CREATED) {
             assert !sActivityInfo.containsKey(activity);
             sActivityInfo.put(activity, new ActivityInfo());
         }
 
         // Invalidate the cached application state.
-        sCachedApplicationState = null;
+        synchronized (sCachedApplicationStateLock) {
+            sCachedApplicationState = null;
+        }
 
         ActivityInfo info = sActivityInfo.get(activity);
         info.setStatus(newState);
 
         // Notify all state observers that are specifically listening to this activity.
         for (ActivityStateListener listener : info.getListeners()) {
             listener.onActivityStateChange(activity, newState);
         }
 
         // Notify all state observers that are listening globally for all activity state
@@ skipping 27 matching lines @@
      *         out of all the activities tracked here, it has most recently gained window focus.
      */
     public static Activity getLastTrackedFocusedActivity() {
         return sActivity;
     }
 
     /**
      * @return A {@link List} of all non-destroyed {@link Activity}s.
      */
     public static List<WeakReference<Activity>> getRunningActivities() {
-        ThreadUtils.assertOnUiThread();
         List<WeakReference<Activity>> activities = new ArrayList<WeakReference<Activity>>();
         for (Activity activity : sActivityInfo.keySet()) {
             activities.add(new WeakReference<Activity>(activity));
         }
         return activities;
     }
 
     /**
      * @return The {@link Context} for the {@link Application}.
      */
@@ skipping 46 matching lines @@
      */
     public static int getStateForActivity(Activity activity) {
         ActivityInfo info = sActivityInfo.get(activity);
         return info != null ? info.getStatus() : ActivityState.DESTROYED;
     }
 
     /**
      * @return The state of the application (see {@link ApplicationState}).
      */
     public static int getStateForApplication() {
-        if (sCachedApplicationState == null) sCachedApplicationState = determineApplicationState();
+        synchronized (sCachedApplicationStateLock) {
+            if (sCachedApplicationState == null) {
+                sCachedApplicationState = determineApplicationState();
+            }
+        }
 
         return sCachedApplicationState.intValue();
     }
 
     /**
      * Checks whether or not any Activity in this Application is visible to the user.  Note that
      * this includes the PAUSED state, which can happen when the Activity is temporarily covered
      * by another Activity's Fragment (e.g.).
      * @return Whether any Activity under this Application is visible.
      */
@@ skipping 117 matching lines @@
 
         if (hasPausedActivity) return ApplicationState.HAS_PAUSED_ACTIVITIES;
         if (hasStoppedActivity) return ApplicationState.HAS_STOPPED_ACTIVITIES;
         return ApplicationState.HAS_DESTROYED_ACTIVITIES;
     }
 
     // Called to notify the native side of state changes.
     // IMPORTANT: This is always called on the main thread!
     private static native void nativeOnApplicationStateChange(int newState);
 }