[Doodle] Add UMA for doodle image downloads

components/search_provider_logos/logo_tracker.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 "components/search_provider_logos/logo_tracker.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/command_line.h"
@@ skipping 243 matching lines @@
                                      traffic_annotation);
   fetcher_->SetRequestContext(request_context_getter_.get());
   data_use_measurement::DataUseUserData::AttachToFetcher(
       fetcher_.get(),
       data_use_measurement::DataUseUserData::SEARCH_PROVIDER_LOGOS);
   fetcher_->Start();
   logo_download_start_time_ = base::TimeTicks::Now();
 }
 
 void LogoTracker::OnFreshLogoParsed(bool* parsing_failed,
+                                    bool from_http_cache,
                                     std::unique_ptr<EncodedLogo> logo) {
   DCHECK(!is_idle_);
 
   if (logo)
     logo->metadata.source_url = logo_url_.spec();
 
   if (!logo || !logo->encoded_image.get()) {
-    OnFreshLogoAvailable(std::move(logo), *parsing_failed, SkBitmap());
+    OnFreshLogoAvailable(std::move(logo), *parsing_failed, from_http_cache,
+                         SkBitmap());
   } else {
     // Store the value of logo->encoded_image for use below. This ensures that
     // logo->encoded_image is evaulated before base::Passed(&logo), which sets
     // logo to NULL.
     scoped_refptr<base::RefCountedString> encoded_image = logo->encoded_image;
     logo_delegate_->DecodeUntrustedImage(
         encoded_image,
         base::Bind(&LogoTracker::OnFreshLogoAvailable,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   base::Passed(&logo),
-                   *parsing_failed));
+                   weak_ptr_factory_.GetWeakPtr(), base::Passed(&logo),
+                   *parsing_failed, from_http_cache));
   }
 }
 
 void LogoTracker::OnFreshLogoAvailable(
     std::unique_ptr<EncodedLogo> encoded_logo,
     bool parsing_failed,
+    bool from_http_cache,
     const SkBitmap& image) {
   DCHECK(!is_idle_);
 
   int download_outcome = kDownloadOutcomeNotTracked;
 
   if (encoded_logo && !encoded_logo->encoded_image.get() && cached_logo_ &&
       !encoded_logo->metadata.fingerprint.empty() &&
       encoded_logo->metadata.fingerprint ==
           cached_logo_->metadata.fingerprint) {
     // The cached logo was revalidated, i.e. its fingerprint was verified.
     // mime_type isn't sent when revalidating, so copy it from the cached logo.
     encoded_logo->metadata.mime_type = cached_logo_->metadata.mime_type;
     SetCachedMetadata(encoded_logo->metadata);
     download_outcome = DOWNLOAD_OUTCOME_LOGO_REVALIDATED;
   } else if (encoded_logo && image.isNull()) {
     // Image decoding failed. Do nothing.
     download_outcome = DOWNLOAD_OUTCOME_DECODING_FAILED;
   } else {
     std::unique_ptr<Logo> logo;
     // Check if the server returned a valid, non-empty response.
     if (encoded_logo) {
+      UMA_HISTOGRAM_BOOLEAN("NewTabPage.LogoImageDownloaded", from_http_cache);
+
       DCHECK(!image.isNull());
       logo.reset(new Logo());
       logo->metadata = encoded_logo->metadata;
       logo->image = image;
     }
 
     if (logo) {
       download_outcome = DOWNLOAD_OUTCOME_NEW_LOGO_SUCCESS;
     } else {
       if (parsing_failed)
@@ skipping 33 matching lines @@
     return;
   }
 
   UMA_HISTOGRAM_TIMES("NewTabPage.LogoDownloadTime",
                       base::TimeTicks::Now() - logo_download_start_time_);
 
   std::unique_ptr<std::string> response(new std::string());
   source->GetResponseAsString(response.get());
   base::Time response_time = clock_->Now();
 
+  bool from_http_cache = source->WasCached();

[justincohen, 2017/03/21 15:03:52]

Can we test this?

[Marc Treib, 2017/03/21 15:37:00]

What exactly would you want to get tested?

[justincohen, 2017/03/21 15:48:52]

I'm curious if this works on iOS, specifically.

[Marc Treib, 2017/03/21 15:54:21]

"This" being the WasCached() method on URLFetcher? TBH, I just assumed the basic
net/ functionality would work on all platforms...

In practice, it should always be false here anyway - the /async/newtab_mobile
responses shouldn't get cached. It'll get more interesting once we have the ios
equivalent of the change to logo_bridge.cc - and I guess then UMA will tell us
if it works on ios. I'll also manually check that it works before launching
anything on ios.

Is that good enough, or were you looking for something else?

+
   bool* parsing_failed = new bool(false);
   base::PostTaskAndReplyWithResult(
       background_task_runner_.get(), FROM_HERE,
       base::Bind(parse_logo_response_func_, base::Passed(&response),
                  response_time, parsing_failed),
       base::Bind(&LogoTracker::OnFreshLogoParsed,
-                 weak_ptr_factory_.GetWeakPtr(), base::Owned(parsing_failed)));
+                 weak_ptr_factory_.GetWeakPtr(), base::Owned(parsing_failed),
+                 from_http_cache));
 }
 
 void LogoTracker::OnURLFetchDownloadProgress(const net::URLFetcher* source,
                                              int64_t current,
                                              int64_t total,
                                              int64_t current_network_bytes) {
   if (total > kMaxDownloadBytes || current > kMaxDownloadBytes) {
     LOG(WARNING) << "Search provider logo exceeded download size limit";
     ReturnToIdle(DOWNLOAD_OUTCOME_DOWNLOAD_FAILED);
   }
 }
 
 }  // namespace search_provider_logos