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 <vector>
 
 #include "base/bind.h"
@@ skipping 12 matching lines @@
 #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 "chrome/test/base/chrome_process_util.h"
 #include "content/public/browser/browser_child_process_host.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 {
 const uint32 kAccessFlags = base::kProcessAccessDuplicateHandle |
                             base::kProcessAccessQueryInformation |
@@ skipping 96 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) {
+  DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
+  database_->AddMetric(type, value);
+}
+
 void PerformanceMonitor::NotifyInitialized() {
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PERFORMANCE_MONITOR_INITIALIZED,
       content::Source<PerformanceMonitor>(this),
       content::NotificationService::NoDetails());
 }
 
 void PerformanceMonitor::GatherStatisticsOnBackgroundThread() {
   CHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 171 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::AddExtensionEvent(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