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 org.chromium.chrome.browser.download.DownloadUtils;
 
 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 was sent for decoding.
+        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);
+
+                int sizeInKB = bitmap.getByteCount() / DownloadUtils.BYTES_PER_KILOBYTE;
+                RecordHistogram.recordCustomCountHistogram(
+                        "Android.PhotoPicker.ImageByteCount", sizeInKB, 1, 500000, 50);

[Theresa, 2017/06/01 15:58:04]

500MB seems rather high to me; can the max be lower e.g. 100MB?

+            }
             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);
             }
         }
     }
 }