Photo Picker dialog: Add UMA statistics.

chrome/android/java/src/org/chromium/chrome/browser/photo_picker/DecoderServiceHost.java

 // Copyright 2017 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.photo_picker;
 
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.ServiceConnection;
 import android.graphics.Bitmap;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.IBinder;
 import android.os.Message;
 import android.os.Messenger;
 import android.os.ParcelFileDescriptor;
 import android.os.RemoteException;
 import android.os.StrictMode;
+import android.os.SystemClock;
 
 import org.chromium.base.Log;
+import org.chromium.base.metrics.RecordHistogram;
 
 import java.io.File;
 import java.io.FileDescriptor;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.lang.ref.WeakReference;
 import java.util.LinkedHashMap;
+import java.util.concurrent.TimeUnit;
 
 /**
  * A class to communicate with the {@link DecoderService}.
  */
 public class DecoderServiceHost {
     // A tag for logging error messages.
     private static final String TAG = "ImageDecoderHost";
 
     /**
      * Interface for notifying clients of the service being ready.
@@ skipping 47 matching lines @@
     private static class DecoderServiceParams {
         // The path to the file containing the bitmap to decode.
         public String mFilePath;
 
         // The requested size (width and height) of the bitmap, once decoded.
         public int mSize;
 
         // The callback to use to communicate the results of the decoding.
         ImageDecodedCallback mCallback;
 
+        // The timestamp for when the request is being sent over for decoding.

[Theresa, 2017/05/31 18:40:02]

nit: ...when the request was sent..

[Finnur, 2017/06/01 15:13:55]

Done.

+        long mTimestamp;
+
         public DecoderServiceParams(String filePath, int size, ImageDecodedCallback callback) {
             mFilePath = filePath;
             mSize = size;
             mCallback = callback;
         }
     }
 
     // Map of file paths to decoder parameters in order of request.
     private LinkedHashMap<String, DecoderServiceParams> mRequests = new LinkedHashMap<>();
     LinkedHashMap<String, DecoderServiceParams> getRequests() {
@@ skipping 56 matching lines @@
         mRequests.put(filePath, params);
         if (mRequests.size() == 1) dispatchNextDecodeImageRequest();
     }
 
     /**
      * Dispatches the next image for decoding (from the queue).
      */
     private void dispatchNextDecodeImageRequest() {
         if (mRequests.entrySet().iterator().hasNext()) {
             DecoderServiceParams params = mRequests.entrySet().iterator().next().getValue();
+            params.mTimestamp = SystemClock.elapsedRealtime();
             dispatchDecodeImageRequest(params.mFilePath, params.mSize);
         }
     }
 
     /**
      * Ties up all the loose ends from the decoding request (communicates the results of the
      * decoding process back to the client, and takes care of house-keeping chores regarding
      * the request queue).
      * @param filePath The path to the image that was just decoded.
      * @param bitmap The resulting decoded bitmap.
+     * @param decodeTime The length of time it took to decode the bitmap.
      */
-    public void closeRequest(String filePath, Bitmap bitmap) {
+    public void closeRequest(String filePath, Bitmap bitmap, long decodeTime) {
         DecoderServiceParams params = getRequests().get(filePath);
         if (params != null) {
+            long endRpcCall = SystemClock.elapsedRealtime();
+            RecordHistogram.recordTimesHistogram("Android.PhotoPicker.RequestProcessTime",
+                    endRpcCall - params.mTimestamp, TimeUnit.MILLISECONDS);
+
             params.mCallback.imageDecodedCallback(filePath, bitmap);
+
+            if (decodeTime != -1) {
+                RecordHistogram.recordTimesHistogram(
+                        "Android.PhotoPicker.ImageDecodeTime", decodeTime, TimeUnit.MILLISECONDS);
+            }

[Theresa, 2017/05/31 18:40:02]

It would also be interesting to record the size of the bitmap so that we can get
an idea of memory usage per bitmap and the number of images decoded (maybe in
the initial request after we have the file list).

[Finnur, 2017/06/01 15:13:55]

I've added metrics for CacheHits for the high-res photos as well as a counter
for the decode requests. I think it is better to keep track of that over the
lifetime of the dialog, instead of at some point in the middle, because we want
one number to be reported for each stat. Specifically I'm trying to avoid this
scenario:

1. Open dialog (UMA reports 16 decode requests, 0 cache hits).
2. Scroll down (UMA reports 16 decode requests, 0 cache hits).
3. Scroll up   (UMA reports 0 decode requests, 16 cache hits).
4. Close dialog

Probably better to just send one stat at step 4 (32 decode requests, 16 cache
hits).

             getRequests().remove(filePath);
         }
         dispatchNextDecodeImageRequest();
     }
 
     /**
      * Communicates with the server to decode a single bitmap.
      * @param filePath The path to the image on disk.
      * @param size The requested width and height of the resulting bitmap.
      */
     private void dispatchDecodeImageRequest(String filePath, int size) {
         // Obtain a file descriptor to send over to the sandboxed process.
         File file = new File(filePath);
         FileInputStream inputFile = null;
         ParcelFileDescriptor pfd = null;
         Bundle bundle = new Bundle();
 
         // The restricted utility process can't open the file to read the
         // contents, so we need to obtain a file descriptor to pass over.
         StrictMode.ThreadPolicy oldPolicy = StrictMode.allowThreadDiskReads();
         try {
             try {
                 inputFile = new FileInputStream(file);
                 FileDescriptor fd = inputFile.getFD();
                 pfd = ParcelFileDescriptor.dup(fd);
                 bundle.putParcelable(DecoderService.KEY_FILE_DESCRIPTOR, pfd);
             } catch (IOException e) {
                 Log.e(TAG, "Unable to obtain FileDescriptor: " + e);
-                closeRequest(filePath, null);
+                closeRequest(filePath, null, -1);
             }
         } finally {
             try {
                 if (inputFile != null) inputFile.close();
             } catch (IOException e) {
                 Log.e(TAG, "Unable to close inputFile: " + e);
             }
             StrictMode.setThreadPolicy(oldPolicy);
         }
 
         if (pfd == null) return;
 
         // Prepare and send the data over.
         Message payload = Message.obtain(null, DecoderService.MSG_DECODE_IMAGE);
         payload.replyTo = mMessenger;
         bundle.putString(DecoderService.KEY_FILE_PATH, filePath);
         bundle.putInt(DecoderService.KEY_SIZE, size);
         payload.setData(bundle);
         try {
             mService.send(payload);
             pfd.close();
         } catch (RemoteException e) {
             Log.e(TAG, "Communications failed (Remote): " + e);
-            closeRequest(filePath, null);
+            closeRequest(filePath, null, -1);
         } catch (IOException e) {
             Log.e(TAG, "Communications failed (IO): " + e);
-            closeRequest(filePath, null);
+            closeRequest(filePath, null, -1);
         }
     }
 
     /**
      * Cancels a request to decode an image (if it hasn't already been dispatched).
      * @param filePath The path to the image to cancel decoding.
      */
     public void cancelDecodeImage(String filePath) {
         mRequests.remove(filePath);
     }
@@ skipping 24 matching lines @@
             switch (msg.what) {
                 case DecoderService.MSG_IMAGE_DECODED_REPLY:
                     Bundle payload = msg.getData();
 
                     // Read the reply back from the service.
                     String filePath = payload.getString(DecoderService.KEY_FILE_PATH);
                     Boolean success = payload.getBoolean(DecoderService.KEY_SUCCESS);
                     Bitmap bitmap = success
                             ? (Bitmap) payload.getParcelable(DecoderService.KEY_IMAGE_BITMAP)
                             : null;
-                    host.closeRequest(filePath, bitmap);
+                    long decodeTime = payload.getLong(DecoderService.KEY_DECODE_TIME);
+                    host.closeRequest(filePath, bitmap, decodeTime);
                     break;
                 default:
                     super.handleMessage(msg);
             }
         }
     }
 }