Add UMA metrics to Photo Editor

chrome/browser/resources/file_manager/js/image_editor/image_view.js

 // Copyright (c) 2011 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.
 
 /**
  * The overlay displaying the image.
  */
 function ImageView(container, viewport) {
   this.container_ = container;
   this.viewport_ = viewport;
@@ skipping 17 matching lines @@
   // the content cache any more. Screen-scale images are small (~1Mpix)
   // so we can afford to cache more of them.
   this.screenCache_ = new ImageView.Cache(5);
   this.contentCallbacks_ = [];
 }
 
 ImageView.ANIMATION_DURATION = 180;
 ImageView.ANIMATION_WAIT_INTERVAL = ImageView.ANIMATION_DURATION * 2;
 ImageView.FAST_SCROLL_INTERVAL = 300;
 
+ImageView.LOAD_TYPE_CACHED_FULL = 0;
+ImageView.LOAD_TYPE_CACHED_SCREEN = 1;
+ImageView.LOAD_TYPE_FILE = 2;
+ImageView.LOAD_TYPE_TOTAL = 3;
+
 ImageView.prototype = {__proto__: ImageBuffer.Overlay.prototype};
 
 // Draw below overlays with the default zIndex.
 ImageView.prototype.getZIndex = function() { return -1 };
 
 ImageView.prototype.draw = function() {
   var forceRepaint = false;
 
   var screenClipped = this.viewport_.getScreenClipped();
 
@@ skipping 98 matching lines @@
  * @param {Object} metadata
  * @param {Object} slide Slide-in animation direction.
  * @param {function(boolean} opt_callback The parameter is true if the image
  *    was loaded instantly (from the cache of the canvas source).
  */
 ImageView.prototype.load = function(
     id, source, metadata, slide, opt_callback) {
 
   metadata = metadata|| {};
 
-  ImageUtil.trace.resetTimer('load');
+  if (ImageUtil.metrics) {
+    ImageUtil.metrics.startInterval(ImageUtil.getMetricName('DisplayTime'));
+  }
 
   var self = this;
 
   this.contentID_ = id;
 
   var readyContent = this.getReadyContent(id, source);
   if (readyContent) {
-    displayMainImage(readyContent, true);
+    displayMainImage(ImageView.LOAD_TYPE_CACHED_FULL, readyContent);
   } else {
     var cachedScreen = this.screenCache_.getItem(id);
     if (cachedScreen) {
-      // We have a cached screen-scale canvas, use it as a thumbnail.
-      displayThumbnail(cachedScreen);
+      // We have a cached screen-scale canvas, use it instead of a thumbnail.
+      displayThumbnail(ImageView.LOAD_TYPE_CACHED_SCREEN, cachedScreen);
+      // As far as the user can tell the image is loaded. We still need to load
+      // the full res image to make editing possible, but we can report now.
+      ImageUtil.metrics.recordInterval(ImageUtil.getMetricName('DisplayTime'));
     } else if (metadata.thumbnailURL) {
       this.imageLoader_.load(
           metadata.thumbnailURL,
           metadata.thumbnailTransform,
-          displayThumbnail);
+          displayThumbnail.bind(null, ImageView.LOAD_TYPE_FILE));
     } else {
-      loadMainImage(0);
+      loadMainImage(ImageView.LOAD_TYPE_FILE, 0);
     }
   }
 
-  function displayThumbnail(canvas) {
+  function displayThumbnail(loadType, canvas) {
     // The thumbnail may have different aspect ratio than the main image.
     // Force the main image proportions to avoid flicker.
     var time = Date.now();
 
     var mainImageLoadDelay = ImageView.ANIMATION_WAIT_INTERVAL;
 
     // Do not do slide-in animation when scrolling very fast.
     if (self.lastLoadTime_ &&
         (time - self.lastLoadTime_) < ImageView.FAST_SCROLL_INTERVAL) {
       slide = 0;
     }
     self.lastLoadTime_ = time;
 
     self.replace(canvas, slide, metadata.width, metadata.height);
     if (!slide) mainImageLoadDelay = 0;
     slide = 0;
-    loadMainImage(mainImageLoadDelay);
+    loadMainImage(loadType, mainImageLoadDelay);
   }
 
-  function loadMainImage(delay) {
+  function loadMainImage(loadType, delay) {
     if (self.prefetchLoader_.isLoading(source)) {
       // The image we need is already being prefetched. Initiating another load
       // would be a waste. Hijack the load instead by overriding the callback.
-      self.prefetchLoader_.setCallback(displayMainImage);
+      self.prefetchLoader_.setCallback(displayMainImage.bind(null, loadType));
 
       // Swap the loaders so that the self.isLoading works correctly.
       var temp = self.prefetchLoader_;
       self.prefetchLoader_ = self.imageLoader_;
       self.imageLoader_ = temp;
       return;
     }
     self.prefetchLoader_.cancel();  // The prefetch was doing something useless.
 
     self.imageLoader_.load(
         source,
         metadata.imageTransform,
-        displayMainImage,
+        displayMainImage.bind(null, loadType),
         delay);
   }
 
-  function displayMainImage(canvas, opt_fastLoad) {
+  function displayMainImage(loadType, canvas) {
     self.replace(canvas, slide);
-    ImageUtil.trace.reportTimer('load');
-    ImageUtil.trace.report('load-type', opt_fastLoad ? 'cached' : 'file');
-    if (opt_callback) opt_callback(opt_fastLoad);
+    ImageUtil.metrics.recordEnum(ImageUtil.getMetricName('DisplayMode'),
+        loadType, ImageView.LOAD_TYPE_TOTAL);
+    if (loadType != ImageView.LOAD_TYPE_CACHED_SCREEN) {
+      ImageUtil.metrics.recordInterval(ImageUtil.getMetricName('DisplayTime'));
+    }
+    if (opt_callback) opt_callback(loadType == ImageView.LOAD_TYPE_CACHED_FULL);

[dgozman, 2011/12/06 15:45:56]

I believe that callback now accepts the loadType instead of boolean.

[Vladislav Kaznacheev, 2011/12/06 16:07:44]

Good catch, thanks!
On 2011/12/06 15:45:56, dgozman wrote:

   }
 };
 
 /**
  * Try to get the canvas from the content cache or from the source.
  *
  * @param {number} id Unique image id for caching purposes
  * @param {string|HTMLCanvasElement} source
  */
 ImageView.prototype.getReadyContent = function(id, source) {
@@ skipping 226 matching lines @@
   if (this.order_.length > this.capacity_)
     throw new Error('Exceeded cache capacity');
 };
 
 ImageView.Cache.prototype.evictLRU = function() {
   if (this.order_.length == this.capacity_) {
     var id = this.order_.shift();
     delete this.map_[id];
   }
 };