Track ga.js through the cache.

net/http/infinite_cache.cc

 // Copyright (c) 2012 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 "net/http/infinite_cache.h"
 
 #include <algorithm>
 
 #include "base/compiler_specific.h"
 #include "base/bind.h"
@@ skipping 27 matching lines @@
 
 // Flags to use with a particular resource.
 enum Flags {
   NO_CACHE = 1 << 0,
   NO_STORE = 1 << 1,
   EXPIRED = 1 << 2,
   TRUNCATED = 1 << 3,
   RESUMABLE = 1 << 4,
   REVALIDATEABLE = 1 << 5,
   DOOM_METHOD = 1 << 6,
-  CACHED = 1 << 7
+  CACHED = 1 << 7,
+  GA_JS_HTTP = 1 << 8,
+  GA_JS_HTTPS = 1 << 9,
 };
 
+const char kGaJsHttpUrl[] = "http://www.google-analytics.com/ga.js";
+const char kGaJsHttpsUrl[] = "https://ssl.google-analytics.com/ga.js";
+
 const int kKeySizeBytes = 20;
 COMPILE_ASSERT(base::kSHA1Length == static_cast<unsigned>(kKeySizeBytes),
                invalid_key_length);
 struct Key {
   char value[kKeySizeBytes];
 };
 
 // The actual data that we store for every resource.
 struct Details {
   int32 expiration;
@@ skipping 168 matching lines @@
 struct InfiniteCacheTransaction::ResourceData {
   ResourceData() {
     memset(this, 0, sizeof(*this));
   }
 
   Key key;
   Details details;
 };
 
 InfiniteCacheTransaction::InfiniteCacheTransaction(InfiniteCache* cache)
-    : cache_(cache->AsWeakPtr()), must_doom_entry_(false) {
+    : cache_(cache->AsWeakPtr()) {
 }
 
 InfiniteCacheTransaction::~InfiniteCacheTransaction() {
   Finish();
 }
 
 void InfiniteCacheTransaction::OnRequestStart(const HttpRequestInfo* request) {
   if (!cache_)
     return;
 
   std::string method = request->method;
   if (method == "POST" || method == "DELETE" || method == "PUT") {
-    must_doom_entry_ = true;
+    resource_data_->details.flags |= DOOM_METHOD;
   } else if (method != "GET") {
     cache_.reset();
     return;
   }
+  const std::string cache_key = cache_->GenerateKey(request);
+  if (cache_key == kGaJsHttpUrl) {
+    resource_data_->details.flags &= GA_JS_HTTP;

[rvargas (doing something else), 2012/09/29 02:28:16]

I meant this one (and the next one)

[willchan no longer on Chromium, 2012/09/29 02:31:21]

Argh, I fail. Thanks for the careful review. Done now.

+  } else if (cache_key == kGaJsHttpsUrl) {
+    resource_data_->details.flags &= GA_JS_HTTPS;
+  }
 
-  resource_data_.reset(new ResourceData);
-  CryptoHash(cache_->GenerateKey(request), &resource_data_->key);
+  CryptoHash(cache_key, &resource_data_->key);
 }
 
 void InfiniteCacheTransaction::OnResponseReceived(
     const HttpResponseInfo* response) {
   if (!cache_)
     return;
 
   Details& details = resource_data_->details;
 
+  // Store the old flag values that we want to preserve.
+  const uint32 kPreserveFlagsBitMask = (GA_JS_HTTP | GA_JS_HTTPS | DOOM_METHOD);
+  uint32 old_flag_values = details.flags & kPreserveFlagsBitMask;
+
   details.expiration = GetExpiration(response);
   details.last_access = TimeToInt(response->request_time);
   details.flags = GetCacheability(response);
   details.vary_hash = GetVaryHash(response);
   details.response_hash = adler32(0, Z_NULL, 0);  // Init the hash.
 
   if (!details.flags &&
       TimeToInt(response->response_time) == details.expiration) {
     details.flags = EXPIRED;
   }
+
+  // Restore the old flag values we wanted to preserve.
+  details.flags |= old_flag_values;
+
   details.flags |= GetRevalidationFlags(response);
 
-  if (must_doom_entry_)
-    details.flags |= DOOM_METHOD;
-
   Pickle pickle;
   response->Persist(&pickle, true, false);  // Skip transient headers.
   details.headers_size = pickle.size();
   details.headers_hash = adler32(0, Z_NULL, 0);
   details.headers_hash = adler32(details.headers_hash,
                                  reinterpret_cast<const Bytef*>(pickle.data()),
                                  pickle.size());
 }
 
 void InfiniteCacheTransaction::OnDataRead(const char* data, int data_len) {
@@ skipping 471 matching lines @@
 
 void InfiniteCache::Worker::UpdateSize(int old_size, int new_size) {
   header_->total_size += new_size - old_size;
   DCHECK_GE(header_->total_size, 0);
 }
 
 void InfiniteCache::Worker::RecordHit(const Details& old, Details* details) {
   header_->num_hits++;
   int access_delta = (IntToTime(details->last_access) -
                       IntToTime(old.last_access)).InMinutes();
-  if (old.use_count)
+  if (old.use_count) {
     UMA_HISTOGRAM_COUNTS("InfiniteCache.ReuseAge", access_delta);
-  else
+    if (details->flags & GA_JS_HTTP) {
+      UMA_HISTOGRAM_COUNTS("InfiniteCache.GaJsHttpReuseAge", access_delta);
+    } else if (details->flags & GA_JS_HTTPS) {
+      UMA_HISTOGRAM_COUNTS("InfiniteCache.GaJsHttpsReuseAge", access_delta);
+    }
+  } else {
     UMA_HISTOGRAM_COUNTS("InfiniteCache.FirstReuseAge", access_delta);
+    if (details->flags & GA_JS_HTTP) {
+      UMA_HISTOGRAM_COUNTS(
+          "InfiniteCache.GaJsHttpFirstReuseAge", access_delta);
+    } else if (details->flags & GA_JS_HTTPS) {
+      UMA_HISTOGRAM_COUNTS(
+          "InfiniteCache.GaJsHttpsFirstReuseAge", access_delta);
+    }
+  }
 
   details->use_count = old.use_count;
   if (details->use_count < kuint8max)
     details->use_count++;
   UMA_HISTOGRAM_CUSTOM_COUNTS("InfiniteCache.UseCount", details->use_count, 0,
                               kuint8max, 25);
+  if (details->flags & GA_JS_HTTP) {
+    UMA_HISTOGRAM_CUSTOM_COUNTS("InfiniteCache.GaJsHttpUseCount",
+                                details->use_count, 0, kuint8max, 25);
+  } else if (details->flags & GA_JS_HTTPS) {
+    UMA_HISTOGRAM_CUSTOM_COUNTS("InfiniteCache.GaJsHttpsUseCount",
+                                details->use_count, 0, kuint8max, 25);
+  }
 }
 
 void InfiniteCache::Worker::RecordUpdate(const Details& old, Details* details) {
   int access_delta = (IntToTime(details->last_access) -
                       IntToTime(old.last_access)).InMinutes();
-  if (old.update_count)
+  if (old.update_count) {
     UMA_HISTOGRAM_COUNTS("InfiniteCache.UpdateAge", access_delta);
-  else
+    if (details->flags & GA_JS_HTTP) {
+      UMA_HISTOGRAM_COUNTS(
+          "InfiniteCache.GaJsHttpUpdateAge", access_delta);
+    } else if (details->flags & GA_JS_HTTPS) {
+      UMA_HISTOGRAM_COUNTS(
+          "InfiniteCache.GaJsHttpsUpdateAge", access_delta);
+    }
+  } else {
     UMA_HISTOGRAM_COUNTS("InfiniteCache.FirstUpdateAge", access_delta);
+    if (details->flags & GA_JS_HTTP) {
+      UMA_HISTOGRAM_COUNTS(
+          "InfiniteCache.GaJsHttpFirstUpdateAge", access_delta);
+    } else if (details->flags & GA_JS_HTTPS) {
+      UMA_HISTOGRAM_COUNTS(
+          "InfiniteCache.GaJsHttpsFirstUpdateAge", access_delta);
+    }
+  }
 
   details->update_count = old.update_count;
   if (details->update_count < kuint8max)
     details->update_count++;
 
   UMA_HISTOGRAM_CUSTOM_COUNTS("InfiniteCache.UpdateCount",
                               details->update_count, 0, kuint8max, 25);
+  if (details->flags & GA_JS_HTTP) {
+    UMA_HISTOGRAM_CUSTOM_COUNTS("InfiniteCache.GaJsHttpUpdateCount",
+                                details->update_count, 0, kuint8max, 25);
+  } else if (details->flags & GA_JS_HTTPS) {
+    UMA_HISTOGRAM_CUSTOM_COUNTS("InfiniteCache.GaJsHttpsUpdateCount",
+                                details->update_count, 0, kuint8max, 25);
+  }
   details->use_count = 0;
 }
 
 void InfiniteCache::Worker::GenerateHistograms() {
   bool new_size_step = (header_->total_size / kReportSizeStep !=
                         header_->size_last_report / kReportSizeStep);
   header_->size_last_report = header_->total_size;
   if (!new_size_step && (header_->use_minutes % 60 != 0))
     return;
 
@@ skipping 72 matching lines @@
     reason = REUSE_TRUNCATED;
 
   if (old.vary_hash != current.vary_hash)
     reason = REUSE_VARY;
 
   bool have_to_drop  = (old.flags & TRUNCATED) && !(old.flags & RESUMABLE);
   if (reason && (old.flags & REVALIDATEABLE) && !have_to_drop)
     reason += REUSE_REVALIDATEABLE;
 
   UMA_HISTOGRAM_ENUMERATION("InfiniteCache.ReuseFailure", reason, 15);
+  if (current.flags & GA_JS_HTTP) {
+    UMA_HISTOGRAM_ENUMERATION(
+        "InfiniteCache.GaJsHttpReuseFailure", reason, 15);
+  } else if (current.flags & GA_JS_HTTPS) {
+    UMA_HISTOGRAM_ENUMERATION(
+        "InfiniteCache.GaJsHttpsReuseFailure", reason, 15);
+  }
   return !reason;
 }
 
 bool InfiniteCache::Worker::DataChanged(const Details& old,
                                         const Details& current) {
   if (current.flags & CACHED)
     return false;
 
   bool changed = false;
   if (old.response_size != current.response_size) {
@@ skipping 111 matching lines @@
 int InfiniteCache::FlushDataForTest(const CompletionCallback& callback) {
   DCHECK(worker_);
   int* result = new int;
   task_runner_->PostTaskAndReply(
       FROM_HERE, base::Bind(&InfiniteCache::Worker::Flush, worker_, result),
       base::Bind(&OnComplete, callback, base::Owned(result)));
   return net::ERR_IO_PENDING;
 }
 
 }  // namespace net