Move NewTabPage.LogoShownTime metrics recording into LogoBridge

chrome/browser/android/logo_bridge.cc

 // Copyright 2014 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.
 
 #include "chrome/browser/android/logo_bridge.h"
 
 #include <jni.h>
 #include <stdint.h>
 
 #include "base/android/jni_android.h"
@@ skipping 59 matching lines @@
     JNIEnv* env,
     const search_provider_logos::Logo* logo) {
   if (!logo)
     return ScopedJavaLocalRef<jobject>();
 
   return MakeJavaLogo(env, &logo->image, GURL(logo->metadata.on_click_url),
                       logo->metadata.alt_text,
                       GURL(logo->metadata.animated_url));
 }
 
+class LoadTimeMetricRecorderImpl : public LogoBridge::LoadTimeMetricRecorder {
+ public:
+  LoadTimeMetricRecorderImpl()
+      : logo_load_start_(base::TimeTicks::Now()), is_recording_(true) {}
+
+  void Cancel() override { is_recording_ = false; }
+
+  void Finish() override {
+    if (!is_recording_) {
+      return;
+    }
+    is_recording_ = false;
+    UMA_HISTOGRAM_MEDIUM_TIMES("NewTabPage.LogoShownTime",
+                               base::TimeTicks::Now() - logo_load_start_);
+  }
+
+ private:
+  base::TimeTicks logo_load_start_;
+  bool is_recording_;
+  bool waiting_for_result_;
+};
+
+class LoadTimeMetricRecorderNullImpl
+    : public LogoBridge::LoadTimeMetricRecorder {
+ public:
+  LoadTimeMetricRecorderNullImpl() {}
+  void Cancel() override {}
+  void Finish() override {}
+};
+
 class LogoObserverAndroid : public search_provider_logos::LogoObserver {
  public:
   LogoObserverAndroid(base::WeakPtr<LogoBridge> logo_bridge,
                       JNIEnv* env,
                       jobject j_logo_observer)
-      : logo_bridge_(logo_bridge) {
+      : logo_bridge_(logo_bridge),
+        load_time_recorder_(new LoadTimeMetricRecorderImpl()) {
     j_logo_observer_.Reset(env, j_logo_observer);
   }
 
   ~LogoObserverAndroid() override {}
 
   // seach_provider_logos::LogoObserver:
   void OnLogoAvailable(const search_provider_logos::Logo* logo,
                        bool from_cache) override {
     if (!logo_bridge_)
       return;
 
     JNIEnv* env = base::android::AttachCurrentThread();
     ScopedJavaLocalRef<jobject> j_logo = ConvertLogoToJavaObject(env, logo);
+    load_time_recorder_->Finish();
     Java_LogoObserver_onLogoAvailable(env, j_logo_observer_, j_logo,
                                       from_cache);
   }
 
   void OnObserverRemoved() override { delete this; }
 
  private:
   // The associated LogoBridge. We won't call back to Java if the LogoBridge has
   // been destroyed.
   base::WeakPtr<LogoBridge> logo_bridge_;
 
+  std::unique_ptr<LogoBridge::LoadTimeMetricRecorder> load_time_recorder_;
   base::android::ScopedJavaGlobalRef<jobject> j_logo_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(LogoObserverAndroid);
 };
 
 }  // namespace
 
 class LogoBridge::AnimatedLogoFetcher : public net::URLFetcherDelegate {
  public:
   AnimatedLogoFetcher(
@@ skipping 93 matching lines @@
   animated_logo_fetcher_ = base::MakeUnique<AnimatedLogoFetcher>(
       profile->GetRequestContext());
 }
 
 LogoBridge::~LogoBridge() {}
 
 void LogoBridge::Destroy(JNIEnv* env, const JavaParamRef<jobject>& obj) {
   delete this;
 }
 
+LogoBridge::LoadTimeMetricRecorder* LogoBridge::load_time_recorder() {
+  if (!load_time_recorder_) {
+    load_time_recorder_ = base::MakeUnique<LoadTimeMetricRecorderNullImpl>();
+  }
+  return load_time_recorder_.get();
+}
+
 void LogoBridge::GetCurrentLogo(JNIEnv* env,
                                 const JavaParamRef<jobject>& obj,
                                 const JavaParamRef<jobject>& j_logo_observer) {
   if (doodle_service_) {
     j_logo_observer_.Reset(j_logo_observer);
+    load_time_recorder_ = base::MakeUnique<LoadTimeMetricRecorderImpl>();
 
     // Immediately hand out any current cached config.
-    DoodleConfigReceived(doodle_service_->config(), /*from_cache=*/true);
+    bool cache_hit =
+        DoodleConfigReceived(doodle_service_->config(), /*from_cache=*/true);
     // Also request a refresh, in case something changed.
-    doodle_service_->Refresh();
+    bool refresh_triggered =
+        doodle_service_->Refresh() if (!cache_hit && !refresh_triggered) {
+      load_time_recorder()->Cancel();
+    }
   } else {
     // |observer| is deleted in LogoObserverAndroid::OnObserverRemoved().
     LogoObserverAndroid* observer = new LogoObserverAndroid(
         weak_ptr_factory_.GetWeakPtr(), env, j_logo_observer);
     logo_service_->GetLogo(observer);
   }
 }
 
 void LogoBridge::GetAnimatedLogo(JNIEnv* env,
                                  const JavaParamRef<jobject>& obj,
                                  const JavaParamRef<jobject>& j_callback,
                                  const JavaParamRef<jstring>& j_url) {
   GURL url = GURL(ConvertJavaStringToUTF8(env, j_url));
   animated_logo_fetcher_->Start(env, url, j_callback);
 }
 
 void LogoBridge::OnDoodleConfigUpdated(
     const base::Optional<doodle::DoodleConfig>& maybe_doodle_config) {
   if (j_logo_observer_.is_null()) {
     return;
   }
   DoodleConfigReceived(maybe_doodle_config, /*from_cache=*/false);
 }
 
-void LogoBridge::DoodleConfigReceived(
+bool LogoBridge::DoodleConfigReceived(
     const base::Optional<doodle::DoodleConfig>& maybe_doodle_config,
     bool from_cache) {
   DCHECK(!j_logo_observer_.is_null());
 
   if (!maybe_doodle_config.has_value()) {
     JNIEnv* env = base::android::AttachCurrentThread();
     Java_LogoObserver_onLogoAvailable(
         env, j_logo_observer_, ScopedJavaLocalRef<jobject>(), from_cache);
-    return;
+    return false;
   }
+  load_time_recorder()->WaitForResult();
   const doodle::DoodleConfig& doodle_config = maybe_doodle_config.value();
   // If there is a CTA image, that means the main image is animated. Show the
   // non-animated CTA image first, and load the animated one only when the
   // user requests it.
   bool has_cta = doodle_config.large_cta_image.has_value();
   const GURL& image_url = has_cta ? doodle_config.large_cta_image->url
                                   : doodle_config.large_image.url;
   const GURL& animated_image_url =
       has_cta ? doodle_config.large_image.url : GURL::EmptyGURL();
   // TODO(treib): For interactive doodles, use |fullpage_interactive_url|
   // instead of |target_url|?
   const GURL& on_click_url = doodle_config.target_url;
   const std::string& alt_text = doodle_config.alt_text;
   image_fetcher_->StartOrQueueNetworkRequest(
       image_url.spec(), image_url,
       base::Bind(&LogoBridge::DoodleImageFetched, base::Unretained(this),
                  from_cache, on_click_url, alt_text, animated_image_url));
+  return true;
 }
 
 void LogoBridge::DoodleImageFetched(
     bool config_from_cache,
     const GURL& on_click_url,
     const std::string& alt_text,
     const GURL& animated_image_url,
     const std::string& image_fetch_id,
     const gfx::Image& image,
     const image_fetcher::RequestMetadata& metadata) {
   JNIEnv* env = base::android::AttachCurrentThread();
 
   if (image.IsEmpty()) {
     DLOG(WARNING) << "Failed to download doodle image";
+    load_time_recorder()->Cancel();
     Java_LogoObserver_onLogoAvailable(env, j_logo_observer_,
                                       ScopedJavaLocalRef<jobject>(),
                                       config_from_cache);
     return;
   }
 
   UMA_HISTOGRAM_BOOLEAN("NewTabPage.LogoImageDownloaded",
                         metadata.from_http_cache);
 
+  load_time_recorder()->Finish();
   ScopedJavaLocalRef<jobject> j_logo = MakeJavaLogo(
       env, image.ToSkBitmap(), on_click_url, alt_text, animated_image_url);
   Java_LogoObserver_onLogoAvailable(env, j_logo_observer_, j_logo,
                                     config_from_cache);
 }
 
 // static
 bool RegisterLogoBridge(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }