Per-host V8 histograms.

content/renderer/render_thread_impl.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 "content/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <vector>
@@ skipping 139 matching lines @@
     return true;
   }
 
  private:
   std::string host_;
   double zoom_level_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderViewZoomer);
 };
 
-}  // namespace
+std::string HostToCustomPage(const std::string& host) {
+  if (host == "gmail.com")
+    return ".gmail";

[Charlie Reis, 2012/08/16 16:22:56]

I don't understand how you're defining host.  What is this data being used for?

We generally use the notion of site (registered domain name plus protocol)
because it's a conservative boundary on which pages might be able to script each
other.  In this case, you're missing the fact that subdomains might script each
other (by modifying their document.domain), and you're putting HTTP and HTTPS
into the same bucket (when they are considered different origins).

[marja, 2012/08/21 15:21:15]

Here we don't care about http vs. https. It would only make a difference if
http://something would be a page different from https://something and we'd like
to separate the histograms for them. For these hosts it's not the case.

Also, if a page sets document.domain to be a suffix, we still use the original
domain here, and ignore the suffix, and afaics it's good enough for this
purpose. (If the user navigates to something.docs.com and that page sets its
domain to docs.google.com, we lose that data, but we can probably live with that
for now. I don't know if these properties even do that.)

+  if (host == "docs.google.com")
+    return ".docs";
+  if (host == "plus.google.com")
+    return ".plus";
+  return "";
+}
 
-static void* CreateHistogram(
+std::string custom_host;
+void* CreateHistogram(
     const char *name, int min, int max, size_t buckets) {
   if (min <= 0)
     min = 1;
   base::Histogram* histogram = base::Histogram::FactoryGet(
-      name, min, max, buckets, base::Histogram::kUmaTargetedHistogramFlag);
+      std::string(name) + custom_host, min, max, buckets,
+      base::Histogram::kUmaTargetedHistogramFlag);
   return histogram;
 }
 
-static void AddHistogramSample(void* hist, int sample) {
+void AddHistogramSample(void* hist, int sample) {
   base::Histogram* histogram = static_cast<base::Histogram*>(hist);
   histogram->Add(sample);
 }
 
+}  // namespace
+
 RenderThreadImpl* RenderThreadImpl::current() {
   return lazy_tls.Pointer()->Get();
 }
 
 // When we run plugins in process, we actually run them on the render thread,
 // which means that we need to make the render thread pump UI events.
 RenderThreadImpl::RenderThreadImpl() {
   Init();
 }
 
@@ skipping 586 matching lines @@
 RenderThreadImpl::GetAudioRendererMixerManager() {
   if (!audio_renderer_mixer_manager_.get()) {
     audio_renderer_mixer_manager_.reset(new AudioRendererMixerManager(
         audio_hardware::GetOutputSampleRate(),
         audio_hardware::GetOutputBufferSize()));
   }
 
   return audio_renderer_mixer_manager_.get();
 }
 
+// static
+std::string RenderThreadImpl::CommonHost() {
+  return custom_host;
+}
+
+// static
+void RenderThreadImpl::SetCommonHost(const std::string& host) {
+  std::string new_custom_host = HostToCustomPage(host);
+  if (new_custom_host != custom_host) {
+    v8::V8::SetCreateHistogramFunction(CreateHistogram);
+    custom_host = new_custom_host;
+  }
+}
+
 #if defined(OS_WIN)
 void RenderThreadImpl::PreCacheFont(const LOGFONT& log_font) {
   Send(new ChildProcessHostMsg_PreCacheFont(log_font));
 }
 
 void RenderThreadImpl::ReleaseCachedFonts() {
   Send(new ChildProcessHostMsg_ReleaseCachedFonts());
 }
 
 #endif  // OS_WIN
@@ skipping 248 matching lines @@
 
 scoped_refptr<base::MessageLoopProxy>
 RenderThreadImpl::GetFileThreadMessageLoopProxy() {
   DCHECK(message_loop() == MessageLoop::current());
   if (!file_thread_.get()) {
     file_thread_.reset(new base::Thread("Renderer::FILE"));
     file_thread_->Start();
   }
   return file_thread_->message_loop_proxy();
 }