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 = 1 << 8,
+  GA_JS_HTTPS = 1 << 9,  // 0 means HTTP, 1 means HTTPS
 };
 
 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.
@@ skipping 160 matching lines @@
   size_t operator()(const Key& key) const {
     return base::Hash(key.value, kKeySizeBytes);
   }
 };
 #endif
 
 }  // BASE_HASH_NAMESPACE
 
 namespace net {
 
+static const char kGaJsHttpUrl[] = "http://www.google-analytics.com/ga.js";
+static const char kGaJsHttpsUrl[] = "https://ssl.google-analytics.com/ga.js";
+
 struct InfiniteCacheTransaction::ResourceData {
   ResourceData() {
     memset(this, 0, sizeof(*this));
   }
 
   Key key;
   Details details;
 };
 
 InfiniteCacheTransaction::InfiniteCacheTransaction(InfiniteCache* cache)
     : cache_(cache->AsWeakPtr()), must_doom_entry_(false) {
 }
 
 InfiniteCacheTransaction::~InfiniteCacheTransaction() {
   Finish();
 }
 
 void InfiniteCacheTransaction::OnRequestStart(const HttpRequestInfo* request) {
   if (!cache_)
     return;
 
+  scoped_ptr<ResourceData> resource_data(new ResourceData);
   std::string method = request->method;
   if (method == "POST" || method == "DELETE" || method == "PUT") {
     must_doom_entry_ = true;
   } else if (method != "GET") {
     cache_.reset();
     return;
+  } else {
+    const std::string cache_key = HttpUtil::SpecForRequest(request->url);
+    if (cache_key == kGaJsHttpUrl) {
+      resource_data_->details.flags &= GA_JS;
+    } else if (cache_key == kGaJsHttpsUrl) {
+      resource_data_->details.flags &= GA_JS | GA_JS_HTTPS;
+    }
   }
 
-  resource_data_.reset(new ResourceData);

[rvargas (doing something else), 2012/09/28 21:51:15]

move this line up to line 250 (in this version).

[willchan no longer on Chromium, 2012/09/28 22:07:55]

I'm fine with that, but in the method != "GET" case, we're wasting memory then,
right?

+  resource_data_.swap(resource_data);
   CryptoHash(cache_->GenerateKey(request), &resource_data_->key);
 }
 
 void InfiniteCacheTransaction::OnResponseReceived(
     const HttpResponseInfo* response) {
   if (!cache_)
     return;
 
   Details& details = resource_data_->details;
 
+  // Store the old ga.js flag values.
+  const uint32 kGaJsBitMask = (GA_JS|GA_JS_HTTPS);
+  uint32 old_ga_js_values = details.flags & kGaJsBitMask;
+
   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 ga.js flag values.
+  details.flags |= old_ga_js_values;

[rvargas (doing something else), 2012/09/28 21:51:15]

I knew there was a reason for passing DOOM_METHOD as a bool instead.

2 more bools? otherwise we need to have a mask of flags that can be set from
Sart() 

[willchan no longer on Chromium, 2012/09/28 22:07:55]

I don't get it...why?

+
   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,
@@ skipping 476 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) {
+      if (details->flags & GA_JS_HTTPS) {
+        UMA_HISTOGRAM_COUNTS("InfiniteCache.GaJsHttpsReuseAge", access_delta);
+      } else {
+        UMA_HISTOGRAM_COUNTS("InfiniteCache.GaJsHttpReuseAge", access_delta);
+      }
+    }
+  } else {
     UMA_HISTOGRAM_COUNTS("InfiniteCache.FirstReuseAge", access_delta);
+    if (details->flags & GA_JS) {
+      if (details->flags & GA_JS_HTTPS) {
+        UMA_HISTOGRAM_COUNTS(
+            "InfiniteCache.GaJsHttpsFirstReuseAge", access_delta);
+      } else {
+        UMA_HISTOGRAM_COUNTS(
+            "InfiniteCache.GaJsHttpFirstReuseAge", 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) {
+    if (details->flags & GA_JS_HTTPS) {
+      UMA_HISTOGRAM_CUSTOM_COUNTS("InfiniteCache.GaJsHttpsUseCount",
+                                  details->use_count, 0, kuint8max, 25);
+    } else {
+      UMA_HISTOGRAM_CUSTOM_COUNTS("InfiniteCache.GaJsHttpUseCount",
+                                  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) {
+      if (details->flags & GA_JS_HTTPS) {
+        UMA_HISTOGRAM_COUNTS(
+            "InfiniteCache.GaJsHttpsUpdateAge", access_delta);
+      } else {
+        UMA_HISTOGRAM_COUNTS(
+            "InfiniteCache.GaJsHttpUpdateAge", access_delta);
+      }
+    }
+  } else {
     UMA_HISTOGRAM_COUNTS("InfiniteCache.FirstUpdateAge", access_delta);
+    if (details->flags & GA_JS) {
+      if (details->flags & GA_JS_HTTPS) {
+        UMA_HISTOGRAM_COUNTS(
+            "InfiniteCache.GaJsHttpsFirstUpdateAge", access_delta);
+      } else {
+        UMA_HISTOGRAM_COUNTS(
+            "InfiniteCache.GaJsHttpFirstUpdateAge", 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) {
+    if (details->flags & GA_JS_HTTPS) {
+      UMA_HISTOGRAM_CUSTOM_COUNTS("InfiniteCache.GaJsHttpsUpdateCount",
+                                  details->update_count, 0, kuint8max, 25);
+    } else {
+      UMA_HISTOGRAM_CUSTOM_COUNTS("InfiniteCache.GaJsHttpUpdateCount",
+                                  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) {
+    if (current.flags & GA_JS_HTTPS) {
+      UMA_HISTOGRAM_ENUMERATION(
+          "InfiniteCache.GaJsHttpsReuseFailure", reason, 15);
+    } else {
+      UMA_HISTOGRAM_ENUMERATION(
+          "InfiniteCache.GaJsHttpReuseFailure", 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