CPM Page Load timing

chrome/browser/performance_monitor/performance_monitor.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 "chrome/browser/performance_monitor/performance_monitor.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/process_util.h"
 #include "base/string_number_conversions.h"
 #include "base/threading/worker_pool.h"
 #include "base/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/performance_monitor/constants.h"
 #include "chrome/browser/performance_monitor/database.h"
 #include "chrome/browser/performance_monitor/performance_monitor_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/load_notification_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/web_contents.h"
 
 using content::BrowserThread;
 using extensions::Extension;
 
 namespace {
 
 std::string TimeToString(base::Time time) {
@@ skipping 92 matching lines @@
 
   // Crashes
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_HANG,
       content::NotificationService::AllSources());
   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
       content::NotificationService::AllSources());
 
   // Profiles (for unclean exit)
   registrar_.Add(this, chrome::NOTIFICATION_PROFILE_ADDED,
       content::NotificationService::AllSources());
+
+  // Page load times
+  registrar_.Add(this, content::NOTIFICATION_LOAD_STOP,
+      content::NotificationService::AllSources());
 }
 
 // We check if profiles exited cleanly initialization time in case they were
 // loaded prior to PerformanceMonitor's initialization. Later profiles will be
 // checked through the PROFILE_ADDED notification.
 void PerformanceMonitor::CheckForUncleanExits() {
   std::vector<Profile*> profiles =
       g_browser_process->profile_manager()->GetLoadedProfiles();
 
   for (std::vector<Profile*>::const_iterator iter = profiles.begin();
@@ skipping 62 matching lines @@
       FROM_HERE,
       base::Bind(&PerformanceMonitor::AddEventOnBackgroundThread,
                  base::Unretained(this),
                  base::Passed(event.Pass())));
 }
 
 void PerformanceMonitor::AddEventOnBackgroundThread(scoped_ptr<Event> event) {
   database_->AddEvent(*event.get());
 }
 
+void PerformanceMonitor::AddMetricOnBackgroundThread(MetricType type,
+                                                     const std::string& value) {
+  database_->AddMetric(type, value);

[Yoyo Zhou, 2012/08/10 18:34:04]

Maybe DCHECK that you're on the right thread?

[Devlin, 2012/08/11 18:22:25]

Done.

+}
+
 void PerformanceMonitor::GetStateValueOnBackgroundThread(
     const std::string& key,
     const StateValueCallback& callback) {
   CHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
   std::string state_value = database_->GetStateValue(key);
 
   BrowserThread::PostTask(BrowserThread::UI,
                           FROM_HERE,
                           base::Bind(callback, state_value));
 }
@@ skipping 98 matching lines @@
         BrowserThread::PostBlockingPoolSequencedTask(
             Database::kDatabaseSequenceToken,
             FROM_HERE,
             base::Bind(
                 &PerformanceMonitor::AddUncleanExitEventOnBackgroundThread,
                 base::Unretained(this),
                 profile->GetDebugName()));
       }
       break;
     }
+    case content::NOTIFICATION_LOAD_STOP: {
+      const content::LoadNotificationDetails* load_details =
+        content::Details<content::LoadNotificationDetails>(details).ptr();
+      if (!load_details)
+        break;
+      BrowserThread::PostBlockingPoolSequencedTask(
+          Database::kDatabaseSequenceToken,
+          FROM_HERE,
+          base::Bind(
+              &PerformanceMonitor::AddMetricOnBackgroundThread,
+              base::Unretained(this),
+              METRIC_PAGE_LOAD_TIME,
+              base::Int64ToString(load_details->load_time.ToInternalValue())));
+      break;
+    }
     default: {
       NOTREACHED();
       break;
     }
   }
 }
 
 void PerformanceMonitor::HandleExtensionEvent(EventType type,
                                               const Extension* extension) {
   DCHECK(type == EVENT_EXTENSION_INSTALL ||
@@ skipping 20 matching lines @@
 
   // Determine the type of crash.
   EventType type =
       details.status == base::TERMINATION_STATUS_PROCESS_WAS_KILLED ?
       EVENT_KILLED_BY_OS_CRASH : EVENT_RENDERER_CRASH;
 
   AddEvent(util::CreateCrashEvent(base::Time::Now(), type));
 }
 
 }  // namespace performance_monitor