Trigger the Snippets Scheduler when Resuming Activities

chrome/android/java/src/org/chromium/chrome/browser/init/AsyncInitializationActivity.java

 // Copyright 2015 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.chrome.browser.init;
 
 import android.annotation.SuppressLint;
 import android.annotation.TargetApi;
 import android.app.Activity;
 import android.content.Context;
@@ skipping 45 matching lines @@
     // Time at which onCreate is called. This is uptime, to be sent to native code.
     private long mOnCreateTimestampUptimeMs;
     private Bundle mSavedInstanceState;
     private int mCurrentOrientation = Surface.ROTATION_0;
     private boolean mDestroyed;
     private NativeInitializationController mNativeInitializationController;
     private MemoryUma mMemoryUma;
     private long mLastUserInteractionTime;
     private boolean mIsTablet;
     private boolean mHadWarmStart;
+    private boolean mIsWarmOnResume;
+    private boolean mFirstResume = true;

[Bernhard Bauer, 2017/01/05 16:32:53]

Can you document this member? Specifically, this states whether the _next_ call
to onResume() is going to be the first, not whether the most recent one was the
first.

[fhorschig, 2017/01/05 17:11:13]

Done.

 
     public AsyncInitializationActivity() {
         mHandler = new Handler();
     }
 
     @Override
     protected void onDestroy() {
         mDestroyed = true;
         super.onDestroy();
     }
@@ skipping 211 matching lines @@
     public void onStart() {
         super.onStart();
         mNativeInitializationController.onStart();
     }
 
     @Override
     public void onResume() {
         super.onResume();
         mNativeInitializationController.onResume();
         if (mLaunchBehindWorkaround != null) mLaunchBehindWorkaround.onResume();
+        mIsWarmOnResume = !mFirstResume || hadWarmStart();
+        mFirstResume = false;
     }
 
     @Override
     public void onPause() {
         mNativeInitializationController.onPause();
         super.onPause();
         if (mLaunchBehindWorkaround != null) mLaunchBehindWorkaround.onPause();
     }
 
     @Override
@@ skipping 94 matching lines @@
     }
 
     /**
      * @return Whether the activity had a warm start because the native library was already fully
      *     loaded and initialized.
      */
     public boolean hadWarmStart() {
         return mHadWarmStart;
     }
 
+    /**
+     * If the activity started warm or was at least resumed once, every following resume must be
+     * warm.

[Bernhard Bauer, 2017/01/05 16:32:53]

It seems this comment should go to where we calculate the value, not where we
document the contract.

Then can you be a bit more detailed here about what exactly warm means, and
under which circumstances? Something like, "Whether this activity was warm
(native library loaded and initialized) by the time it was last resumed. This is
useful to distinguish between the case where an already running instance of
Chrome is being brought back to the foreground from the case where Chrome is
started, in order to avoid contention on browser startup".

...And now that I think of it that way, couldn't we get the value in the same
way as hadWarmStart()? That is, in onResume() check whether the native library
is loaded and set the flag based on that. If you want to land this CL in time
for FF though, I'd be okay with trying that out in a followup.

[fhorschig, 2017/01/05 17:11:13]

Done.
Done. Thank you for the wording idea!

 
I think we had that and the problem was, that some cold cold starts take long
enough for the library to load. So technically, it would be cold but it warmed
up during the run.
I can verify this as follow up nonetheless. 

[Bernhard Bauer, 2017/01/05 17:19:45]

What do you mean by long enough? During which run?
That would be great, thanks!

[fhorschig, 2017/01/05 17:23:06]

The first run  (with first run experience) for example.
Should be cold, but wasn't.

+     * @return Whether the activity is warm in onResume.
+     */
+    public boolean isWarmOnResume() {
+        return mIsWarmOnResume;
+    }
+
     @Override
     public void onUserInteraction() {
         mLastUserInteractionTime = SystemClock.elapsedRealtime();
     }
 
     /**
      * @return timestamp when the last user interaction was made.
      */
     public long getLastUserInteractionTime() {
         return mLastUserInteractionTime;
@@ skipping 111 matching lines @@
                             getDecorView().setVisibility(View.GONE);
                         }
                         getViewTreeObserver().removeOnPreDrawListener(mPreDrawListener);
                     }
                 });
                 return true;
             }
         };
     }
 }