Route through a JobService when receiving a message for the GCM Driver

chrome/android/java/src/org/chromium/chrome/browser/services/gcm/ChromeGcmListenerService.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.services.gcm;
 
+import android.app.job.JobInfo;
+import android.app.job.JobScheduler;
+import android.content.ComponentName;
+import android.content.Context;
+import android.os.Build;
 import android.os.Bundle;
 import android.text.TextUtils;
 
 import com.google.android.gms.gcm.GcmListenerService;
 import com.google.ipc.invalidation.ticl.android2.channel.AndroidGcmController;
 
 import org.chromium.base.Log;
 import org.chromium.base.ThreadUtils;
 import org.chromium.base.annotations.SuppressFBWarnings;
 import org.chromium.base.library_loader.ProcessInitException;
+import org.chromium.chrome.browser.JobSchedulerConstants;
 import org.chromium.chrome.browser.init.ChromeBrowserInitializer;
 import org.chromium.chrome.browser.init.ProcessInitializationHandler;
 import org.chromium.components.gcm_driver.GCMDriver;
+import org.chromium.components.gcm_driver.GCMMessage;
 
 /**
  * Receives Downstream messages and status of upstream messages from GCM.
  */
 public class ChromeGcmListenerService extends GcmListenerService {
     private static final String TAG = "ChromeGcmListener";
 
     @Override
     public void onCreate() {
         ProcessInitializationHandler.getInstance().initializePreNative();
         super.onCreate();
     }
 
     @Override
     public void onMessageReceived(String from, Bundle data) {
         boolean hasCollapseKey = !TextUtils.isEmpty(data.getString("collapse_key"));
         GcmUma.recordDataMessageReceived(getApplicationContext(), hasCollapseKey);
 
         String invalidationSenderId = AndroidGcmController.get(this).getSenderId();
         if (from.equals(invalidationSenderId)) {
             AndroidGcmController.get(this).onMessageReceived(data);
             return;
         }
-        pushMessageReceived(from, data);
+
+        GCMMessage message = null;
+        try {
+            message = new GCMMessage(from, data);
+        } catch (IllegalArgumentException e) {
+            Log.e(TAG, "Received an invalid GCM Message", e);
+            return;
+        }
+
+        // Dispatch the message to the GCM Driver for native features.
+        scheduleOrDispatchMessageToDriver(getApplicationContext(), message);
     }
 
     @Override
     public void onMessageSent(String msgId) {
         Log.d(TAG, "Message sent successfully. Message id: " + msgId);
         GcmUma.recordGcmUpstreamHistogram(getApplicationContext(), GcmUma.UMA_UPSTREAM_SUCCESS);
     }
 
     @Override
     public void onSendError(String msgId, String error) {
         Log.w(TAG, "Error in sending message. Message id: " + msgId + " Error: " + error);
         GcmUma.recordGcmUpstreamHistogram(getApplicationContext(), GcmUma.UMA_UPSTREAM_SEND_FAILED);
     }
 
     @Override
     public void onDeletedMessages() {
         // TODO(johnme): Ask GCM to include the subtype in this event.
         Log.w(TAG, "Push messages were deleted, but we can't tell the Service Worker as we don't"
                 + "know what subtype (app ID) it occurred for.");
         GcmUma.recordDeletedMessages(getApplicationContext());
     }
 
-    private void pushMessageReceived(final String from, final Bundle data) {
-        final String bundleSubtype = "subtype";
-        if (!data.containsKey(bundleSubtype)) {
-            Log.w(TAG, "Received push message with no subtype");
-            return;
+    /**
+     * Either schedules |message| to be dispatched through the Job Scheduler, which we use on
+     * Android N and beyond, or immediately dispatches the message on other versions of Android.
+     */
+    static void scheduleOrDispatchMessageToDriver(final Context context, final GCMMessage message) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            // TODO(peter): Add UMA for measuring latency introduced by the JobScheduler.
+            JobInfo job = new JobInfo
+                                  .Builder(JobSchedulerConstants.GCM_DRIVER_JOB_ID,
+                                          new ComponentName(context, GCMJobService.class))
+                                  .setExtras(message.toPersistableBundle())
+                                  .setOverrideDeadline(0)
+                                  .build();
+            JobScheduler scheduler =
+                    (JobScheduler) context.getSystemService(Context.JOB_SCHEDULER_SERVICE);
+            scheduler.schedule(job);
+        } else {
+            ThreadUtils.runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                    ChromeGcmListenerService.dispatchMessageToDriver(context, message);
+                }
+            });
         }
-        final String appId = data.getString(bundleSubtype);
-        ThreadUtils.runOnUiThread(new Runnable() {
-            @Override
-            @SuppressFBWarnings("DM_EXIT")
-            public void run() {
-                try {
-                    ChromeBrowserInitializer.getInstance(getApplicationContext())
-                        .handleSynchronousStartup();
-                    GCMDriver.onMessageReceived(appId, from, data);
-                } catch (ProcessInitException e) {
-                    Log.e(TAG, "ProcessInitException while starting the browser process");
-                    // Since the library failed to initialize nothing in the application
-                    // can work, so kill the whole application not just the activity.
-                    System.exit(-1);
-                }
-            }
-        });
+    }
+
+    /**
+     * To be called when a GCM message is ready to be dispatched. Will initialise the native code
+     * of the browser process, and forward the message to the GCM Driver. Must be called on the UI
+     * thread.
+     */
+    @SuppressFBWarnings("DM_EXIT")
+    static void dispatchMessageToDriver(Context applicationContext, GCMMessage message) {
+        ThreadUtils.assertOnUiThread();
+
+        try {
+            ChromeBrowserInitializer.getInstance(applicationContext).handleSynchronousStartup();
+            GCMDriver.dispatchMessage(message);
+
+        } catch (ProcessInitException e) {
+            Log.e(TAG, "ProcessInitException while starting the browser process");
+
+            // Since the library failed to initialize nothing in the application can work, so kill
+            // the whole application as opposed to just this service.
+            System.exit(-1);
+        }
     }
 }