chrome/browser/performance_monitor/performance_monitor.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/performance_monitor/performance_monitor.h"
   6
   7 #include <set>
   8 #include <vector>
   9
  10 #include "base/bind.h"
  11 #include "base/command_line.h"
  12 #include "base/logging.h"
  13 #include "base/memory/singleton.h"
  14 #include "base/process/process_iterator.h"
  15 #include "base/stl_util.h"
  16 #include "base/strings/string_number_conversions.h"
  17 #include "base/threading/worker_pool.h"
  18 #include "base/time/time.h"
  19 #include "chrome/browser/browser_process.h"
  20 #include "chrome/browser/browser_shutdown.h"
  21 #include "chrome/browser/chrome_notification_types.h"
  22 #include "chrome/browser/extensions/crx_installer.h"
  23 #include "chrome/browser/performance_monitor/constants.h"
  24 #include "chrome/browser/performance_monitor/performance_monitor_util.h"
  25 #include "chrome/browser/profiles/profile.h"
  26 #include "chrome/browser/profiles/profile_manager.h"
  27 #include "chrome/browser/ui/browser.h"
  28 #include "chrome/browser/ui/browser_iterator.h"
  29 #include "chrome/common/chrome_switches.h"
  30 #include "chrome/common/chrome_version_info.h"
  31 #include "chrome/common/extensions/extension_constants.h"
  32 #include "content/public/browser/browser_child_process_host.h"
  33 #include "content/public/browser/browser_child_process_host_iterator.h"
  34 #include "content/public/browser/browser_thread.h"
  35 #include "content/public/browser/child_process_data.h"
  36 #include "content/public/browser/load_notification_details.h"
  37 #include "content/public/browser/notification_service.h"
  38 #include "content/public/browser/notification_types.h"
  39 #include "content/public/browser/render_view_host.h"
  40 #include "content/public/browser/render_widget_host.h"
  41 #include "content/public/browser/render_widget_host_iterator.h"
  42 #include "content/public/browser/web_contents.h"
  43 #include "extensions/common/extension.h"
  44 #include "net/url_request/url_request.h"
  45
  46 using content::BrowserThread;
  47 using extensions::Extension;
  48 using extensions::UnloadedExtensionInfo;
  49
  50 namespace performance_monitor {
  51
  52 namespace {
  53
  54 #if !defined(OS_ANDROID)
  55 std::string TimeToString(base::Time time) {
  56   int64 time_int64 = time.ToInternalValue();
  57   return base::Int64ToString(time_int64);
  58 }
  59 #endif  // !defined(OS_ANDROID)
  60
  61 bool StringToTime(std::string time, base::Time* output) {
  62   int64 time_int64 = 0;
  63   if (!base::StringToInt64(time, &time_int64))
  64     return false;
  65   *output = base::Time::FromInternalValue(time_int64);
  66   return true;
  67 }
  68
  69 // Try to get the URL for the RenderViewHost if the host does not correspond to
  70 // an incognito profile (we don't store URLs from incognito sessions). Returns
  71 // true if url has been populated, and false otherwise.
  72 bool MaybeGetURLFromRenderView(const content::RenderViewHost* view,
  73                                std::string* url) {
  74   content::WebContents* web_contents =
  75       content::WebContents::FromRenderViewHost(view);
  76
  77   if (Profile::FromBrowserContext(
  78           web_contents->GetBrowserContext())->IsOffTheRecord()) {
  79     return false;
  80   }
  81
  82   *url = web_contents->GetURL().spec();
  83   return true;
  84 }
  85
  86 // Takes ownership of and deletes |database| on the background thread, to
  87 // avoid destruction in the middle of an operation.
  88 void DeleteDatabaseOnBackgroundThread(Database* database) {
  89   delete database;
  90 }
  91
  92 }  // namespace
  93
  94 bool PerformanceMonitor::initialized_ = false;
  95
  96 PerformanceMonitor::PerformanceDataForIOThread::PerformanceDataForIOThread()
  97     : network_bytes_read(0) {
  98 }
  99
 100 PerformanceMonitor::PerformanceMonitor()
 101     : gather_interval_in_seconds_(kDefaultGatherIntervalInSeconds),
 102       database_logging_enabled_(false),
 103       timer_(FROM_HERE,
 104              base::TimeDelta::FromSeconds(kSampleIntervalInSeconds),
 105              this,
 106              &PerformanceMonitor::DoTimedCollections),
 107       disable_timer_autostart_for_testing_(false) {
 108 }
 109
 110 PerformanceMonitor::~PerformanceMonitor() {
 111   BrowserThread::PostBlockingPoolSequencedTask(
 112       Database::kDatabaseSequenceToken,
 113       FROM_HERE,
 114       base::Bind(&DeleteDatabaseOnBackgroundThread, database_.release()));
 115 }
 116
 117 bool PerformanceMonitor::SetDatabasePath(const base::FilePath& path) {
 118   if (!database_.get()) {
 119     database_path_ = path;
 120     return true;
 121   }
 122
 123   // PerformanceMonitor already initialized with another path.
 124   return false;
 125 }
 126
 127 // static
 128 PerformanceMonitor* PerformanceMonitor::GetInstance() {
 129   return Singleton<PerformanceMonitor>::get();
 130 }
 131
 132 void PerformanceMonitor::Initialize() {
 133   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 134
 135   if (CommandLine::ForCurrentProcess()->HasSwitch(
 136           switches::kPerformanceMonitorGathering)) {
 137     database_logging_enabled_ = true;
 138
 139     std::string switch_value = CommandLine::ForCurrentProcess()->
 140         GetSwitchValueASCII(switches::kPerformanceMonitorGathering);
 141
 142     if (!switch_value.empty()) {
 143       int specified_interval = 0;
 144       if (!base::StringToInt(switch_value, &specified_interval) ||
 145           specified_interval <= 0) {
 146         LOG(ERROR) << "Invalid value for switch: '"
 147                    << switches::kPerformanceMonitorGathering
 148                    << "'; please use an integer greater than 0.";
 149       } else {
 150         gather_interval_in_seconds_ = std::max(specified_interval,
 151                                                kSampleIntervalInSeconds);
 152       }
 153     }
 154   }
 155
 156   DCHECK(gather_interval_in_seconds_ >= kSampleIntervalInSeconds);
 157
 158   next_collection_time_ = base::Time::Now() +
 159       base::TimeDelta::FromSeconds(gather_interval_in_seconds_);
 160
 161   util::PostTaskToDatabaseThreadAndReply(
 162       FROM_HERE,
 163       base::Bind(&PerformanceMonitor::InitOnBackgroundThread,
 164                  base::Unretained(this)),
 165       base::Bind(&PerformanceMonitor::FinishInit,
 166                  base::Unretained(this)));
 167 }
 168
 169 void PerformanceMonitor::InitOnBackgroundThread() {
 170   CHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
 171
 172   if (database_logging_enabled_) {
 173     if (!database_)
 174       database_ = Database::Create(database_path_);
 175
 176     if (!database_) {
 177       LOG(ERROR) << "Could not initialize database; aborting initialization.";
 178       database_logging_enabled_ = false;
 179       return;
 180     }
 181
 182     // Initialize the io thread's performance data to the value in the database;
 183     // if there isn't a recording in the database, the value stays at 0.
 184     Metric metric;
 185     if (database_->GetRecentStatsForActivityAndMetric(METRIC_NETWORK_BYTES_READ,
 186                                                       &metric)) {
 187       performance_data_for_io_thread_.network_bytes_read = metric.value;
 188     }
 189   }
 190 }
 191
 192 void PerformanceMonitor::FinishInit() {
 193   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 194
 195   // Events and notifications are only useful if we're logging to the database.
 196   if (database_logging_enabled_) {
 197     RegisterForNotifications();
 198     CheckForUncleanExits();
 199     BrowserThread::PostBlockingPoolSequencedTask(
 200         Database::kDatabaseSequenceToken,
 201         FROM_HERE,
 202         base::Bind(&PerformanceMonitor::CheckForVersionUpdateOnBackgroundThread,
 203                    base::Unretained(this)));
 204   }
 205
 206   // Post a task to the background thread to a function which does nothing.
 207   // This will force any tasks the database is performing to finish prior to
 208   // the reply being sent, since they use the same thread.
 209   //
 210   // Important! Make sure that methods in FinishInit() only rely on posting
 211   // to the background thread, and do not rely upon a reply from the background
 212   // thread; this is necessary for this notification to be valid.
 213   util::PostTaskToDatabaseThreadAndReply(
 214       FROM_HERE,
 215       base::Bind(&base::DoNothing),
 216       base::Bind(&PerformanceMonitor::NotifyInitialized,
 217                  base::Unretained(this)));
 218 }
 219
 220 void PerformanceMonitor::StartGatherCycle() {
 221   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 222
 223   // Start our periodic gathering of metrics.
 224   if (!disable_timer_autostart_for_testing_)
 225     timer_.Reset();
 226 }
 227
 228 void PerformanceMonitor::RegisterForNotifications() {
 229   DCHECK(database_logging_enabled_);
 230
 231   // Extensions
 232   registrar_.Add(this,
 233                  chrome::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED,
 234                  content::NotificationService::AllSources());
 235   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_ENABLED,
 236       content::NotificationService::AllSources());
 237   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
 238       content::NotificationService::AllSources());
 239   registrar_.Add(this, chrome::NOTIFICATION_CRX_INSTALLER_DONE,
 240       content::NotificationService::AllSources());
 241   registrar_.Add(this,
 242                  chrome::NOTIFICATION_EXTENSION_UNINSTALLED_DEPRECATED,
 243                  content::NotificationService::AllSources());
 244
 245   // Crashes
 246   registrar_.Add(this, content::NOTIFICATION_RENDER_WIDGET_HOST_HANG,
 247       content::NotificationService::AllSources());
 248   registrar_.Add(this, content::NOTIFICATION_RENDERER_PROCESS_CLOSED,
 249       content::NotificationService::AllSources());
 250
 251   // Profiles (for unclean exit)
 252   registrar_.Add(this, chrome::NOTIFICATION_PROFILE_ADDED,
 253       content::NotificationService::AllSources());
 254
 255   // Page load times
 256   registrar_.Add(this, content::NOTIFICATION_LOAD_STOP,
 257       content::NotificationService::AllSources());
 258 }
 259
 260 // We check if profiles exited cleanly initialization time in case they were
 261 // loaded prior to PerformanceMonitor's initialization. Later profiles will be
 262 // checked through the PROFILE_ADDED notification.
 263 void PerformanceMonitor::CheckForUncleanExits() {
 264   DCHECK(database_logging_enabled_);
 265
 266   std::vector<Profile*> profiles =
 267       g_browser_process->profile_manager()->GetLoadedProfiles();
 268
 269   for (std::vector<Profile*>::const_iterator iter = profiles.begin();
 270        iter != profiles.end(); ++iter) {
 271     if ((*iter)->GetLastSessionExitType() == Profile::EXIT_CRASHED) {
 272       BrowserThread::PostBlockingPoolSequencedTask(
 273           Database::kDatabaseSequenceToken,
 274           FROM_HERE,
 275           base::Bind(&PerformanceMonitor::AddUncleanExitEventOnBackgroundThread,
 276                      base::Unretained(this),
 277                      (*iter)->GetDebugName()));
 278     }
 279   }
 280 }
 281
 282 void PerformanceMonitor::AddUncleanExitEventOnBackgroundThread(
 283     const std::string& profile_name) {
 284   DCHECK(database_logging_enabled_);
 285   std::string database_key = kStateProfilePrefix + profile_name;
 286   std::string last_active_string = database_->GetStateValue(database_key);
 287
 288   // Check if there was no previous time; this should only happen if the profile
 289   // was last used prior to PerformanceMonitor's integration. Do nothing in this
 290   // case, since the event was prior to the beginning of our recording.
 291   if (last_active_string.empty())
 292     return;
 293
 294   base::Time last_active_time;
 295   CHECK(StringToTime(last_active_string, &last_active_time));
 296
 297   scoped_ptr<Event> event =
 298       util::CreateUncleanExitEvent(last_active_time, profile_name);
 299
 300   database_->AddEvent(*event.get());
 301 }
 302
 303 void PerformanceMonitor::CheckForVersionUpdateOnBackgroundThread() {
 304   CHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
 305   DCHECK(database_logging_enabled_);
 306
 307   chrome::VersionInfo version;
 308   DCHECK(version.is_valid());
 309   std::string current_version = version.Version();
 310
 311   std::string previous_version = database_->GetStateValue(kStateChromeVersion);
 312
 313   // We should never have a current_version which is older than the
 314   // previous_version.
 315   DCHECK(current_version >= previous_version);
 316
 317   // If this is the first run, there will not be a stored value for Chrome
 318   // version; we insert the current version and will insert an event for the
 319   // next update of Chrome. If the previous version is older than the current
 320   // version, update the state in the database and insert an event.
 321   if (current_version > previous_version) {
 322     database_->AddStateValue(kStateChromeVersion, current_version);
 323     if (!previous_version.empty()) {
 324       scoped_ptr<Event> event = util::CreateChromeUpdateEvent(
 325           base::Time::Now(), previous_version, current_version);
 326       database_->AddEvent(*event.get());
 327     }
 328   }
 329 }
 330
 331 void PerformanceMonitor::AddEvent(scoped_ptr<Event> event) {
 332   DCHECK(database_logging_enabled_);
 333
 334   BrowserThread::PostBlockingPoolSequencedTask(
 335       Database::kDatabaseSequenceToken,
 336       FROM_HERE,
 337       base::Bind(&PerformanceMonitor::AddEventOnBackgroundThread,
 338                  base::Unretained(this),
 339                  base::Passed(&event)));
 340 }
 341
 342 void PerformanceMonitor::AddEventOnBackgroundThread(scoped_ptr<Event> event) {
 343   database_->AddEvent(*event.get());
 344 }
 345
 346 void PerformanceMonitor::AddMetricOnBackgroundThread(const Metric& metric) {
 347   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
 348   DCHECK(database_logging_enabled_);
 349
 350   database_->AddMetric(metric);
 351 }
 352
 353 void PerformanceMonitor::NotifyInitialized() {
 354   content::NotificationService::current()->Notify(
 355       chrome::NOTIFICATION_PERFORMANCE_MONITOR_INITIALIZED,
 356       content::Source<PerformanceMonitor>(this),
 357       content::NotificationService::NoDetails());
 358
 359   initialized_ = true;
 360 }
 361
 362 void PerformanceMonitor::DoTimedCollections() {
 363 #if !defined(OS_ANDROID)
 364   // The profile list is only useful for the logged events.
 365   if (database_logging_enabled_)
 366     UpdateLiveProfiles();
 367 #endif
 368
 369   GatherMetricsMapOnUIThread();
 370 }
 371
 372 void PerformanceMonitor::GatherMetricsMapOnUIThread() {
 373   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 374   static int current_update_sequence = 0;
 375   // Even in the "somewhat" unlikely event this wraps around,
 376   // it doesn't matter. We just check it for inequality.
 377   current_update_sequence++;
 378
 379   // Find all render child processes; has to be done on the UI thread.
 380   for (content::RenderProcessHost::iterator rph_iter =
 381            content::RenderProcessHost::AllHostsIterator();
 382        !rph_iter.IsAtEnd(); rph_iter.Advance()) {
 383     base::ProcessHandle handle = rph_iter.GetCurrentValue()->GetHandle();
 384     MarkProcessAsAlive(handle, content::PROCESS_TYPE_RENDERER,
 385                        current_update_sequence);
 386   }
 387
 388   BrowserThread::PostTask(
 389       BrowserThread::IO,
 390       FROM_HERE,
 391       base::Bind(&PerformanceMonitor::GatherMetricsMapOnIOThread,
 392                  base::Unretained(this),
 393                  current_update_sequence));
 394 }
 395
 396 void PerformanceMonitor::MarkProcessAsAlive(const base::ProcessHandle& handle,
 397                                         int process_type,
 398                                         int current_update_sequence) {
 399
 400   if (handle == 0) {
 401     // Process may not be valid yet.
 402     return;
 403   }
 404
 405   MetricsMap::iterator process_metrics_iter = metrics_map_.find(handle);
 406   if (process_metrics_iter == metrics_map_.end()) {
 407     // If we're not already watching the process, let's initialize it.
 408     metrics_map_[handle]
 409         .Initialize(handle, process_type, current_update_sequence);
 410   } else {
 411     // If we are watching the process, touch it to keep it alive.
 412     ProcessMetricsHistory& process_metrics = process_metrics_iter->second;
 413     process_metrics.set_last_update_sequence(current_update_sequence);
 414   }
 415 }
 416
 417 #if !defined(OS_ANDROID)
 418 void PerformanceMonitor::UpdateLiveProfiles() {
 419   std::string time = TimeToString(base::Time::Now());
 420   scoped_ptr<std::set<std::string> > active_profiles(
 421       new std::set<std::string>());
 422
 423   for (chrome::BrowserIterator it; !it.done(); it.Next())
 424     active_profiles->insert(it->profile()->GetDebugName());
 425
 426   BrowserThread::PostBlockingPoolSequencedTask(
 427       Database::kDatabaseSequenceToken,
 428       FROM_HERE,
 429       base::Bind(&PerformanceMonitor::UpdateLiveProfilesHelper,
 430                  base::Unretained(this),
 431                  base::Passed(&active_profiles),
 432                  time));
 433 }
 434
 435 void PerformanceMonitor::UpdateLiveProfilesHelper(
 436     scoped_ptr<std::set<std::string> > active_profiles,
 437     std::string time) {
 438   CHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
 439   DCHECK(database_logging_enabled_);
 440
 441   for (std::set<std::string>::const_iterator iter = active_profiles->begin();
 442        iter != active_profiles->end(); ++iter) {
 443     database_->AddStateValue(kStateProfilePrefix + *iter, time);
 444   }
 445 }
 446 #endif
 447
 448 void PerformanceMonitor::GatherMetricsMapOnIOThread(
 449     int current_update_sequence) {
 450   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 451
 452   // Find all child processes (does not include renderers), which has to be
 453   // done on the IO thread.
 454   for (content::BrowserChildProcessHostIterator iter; !iter.Done(); ++iter) {
 455     const content::ChildProcessData& child_process_data = iter.GetData();
 456     base::ProcessHandle handle = child_process_data.handle;
 457     MarkProcessAsAlive(handle, child_process_data.process_type,
 458                        current_update_sequence);
 459   }
 460
 461   // Add the current (browser) process.
 462   MarkProcessAsAlive(base::GetCurrentProcessHandle(),
 463                      content::PROCESS_TYPE_BROWSER, current_update_sequence);
 464
 465   BrowserThread::PostBlockingPoolSequencedTask(
 466       Database::kDatabaseSequenceToken,
 467       FROM_HERE,
 468       base::Bind(&PerformanceMonitor::StoreMetricsOnBackgroundThread,
 469                  base::Unretained(this), current_update_sequence,
 470                  performance_data_for_io_thread_));
 471 }
 472
 473 void PerformanceMonitor::StoreMetricsOnBackgroundThread(
 474     int current_update_sequence,
 475     const PerformanceDataForIOThread& performance_data_for_io_thread) {
 476   CHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
 477
 478   base::Time time_now = base::Time::Now();
 479
 480   // The timing can be off by kSampleIntervalInSeconds during any one particular
 481   // run, but will be correct over time.
 482   bool end_of_cycle = time_now >= next_collection_time_;
 483   if (end_of_cycle) {
 484     next_collection_time_ +=
 485         base::TimeDelta::FromSeconds(gather_interval_in_seconds_);
 486   }
 487
 488   double cpu_usage = 0.0;
 489   size_t private_memory_sum = 0;
 490   size_t shared_memory_sum = 0;
 491
 492   // Update metrics for all watched processes; remove dead entries from the map.
 493   MetricsMap::iterator iter = metrics_map_.begin();
 494   while (iter != metrics_map_.end()) {
 495     ProcessMetricsHistory& process_metrics = iter->second;
 496     if (process_metrics.last_update_sequence() != current_update_sequence) {
 497       // Not touched this iteration; let's get rid of it.
 498       metrics_map_.erase(iter++);
 499     } else {
 500       process_metrics.SampleMetrics();
 501
 502       if (end_of_cycle) {
 503         // Gather averages of previously sampled metrics.
 504         cpu_usage += process_metrics.GetAverageCPUUsage();
 505
 506         size_t private_memory = 0;
 507         size_t shared_memory = 0;
 508         process_metrics.GetAverageMemoryBytes(&private_memory, &shared_memory);
 509         private_memory_sum += private_memory;
 510         shared_memory_sum += shared_memory;
 511
 512         process_metrics.EndOfCycle();
 513       }
 514
 515       ++iter;
 516     }
 517   }
 518
 519   // Store previously-sampled metrics.
 520   if (end_of_cycle && database_logging_enabled_) {
 521     if (!metrics_map_.empty()) {
 522       database_->AddMetric(Metric(METRIC_CPU_USAGE, time_now, cpu_usage));
 523       database_->AddMetric(Metric(METRIC_PRIVATE_MEMORY_USAGE,
 524                                   time_now,
 525                                   static_cast<double>(private_memory_sum)));
 526       database_->AddMetric(Metric(METRIC_SHARED_MEMORY_USAGE,
 527                                   time_now,
 528                                   static_cast<double>(shared_memory_sum)));
 529     }
 530
 531     database_->AddMetric(
 532         Metric(METRIC_NETWORK_BYTES_READ,
 533                time_now,
 534                static_cast<double>(
 535                    performance_data_for_io_thread.network_bytes_read)));
 536   }
 537
 538   BrowserThread::PostTask(
 539       BrowserThread::UI,
 540       FROM_HERE,
 541       base::Bind(&PerformanceMonitor::StartGatherCycle,
 542                  base::Unretained(this)));
 543 }
 544
 545 void PerformanceMonitor::BytesReadOnIOThread(const net::URLRequest& request,
 546                                              const int bytes_read) {
 547   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 548
 549   if (initialized_ && !request.url().SchemeIsFile())
 550     performance_data_for_io_thread_.network_bytes_read += bytes_read;
 551 }
 552
 553 void PerformanceMonitor::Observe(int type,
 554                                  const content::NotificationSource& source,
 555                                  const content::NotificationDetails& details) {
 556   DCHECK(database_logging_enabled_);
 557
 558   switch (type) {
 559     case chrome::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED: {
 560       AddExtensionEvent(
 561           EVENT_EXTENSION_INSTALL,
 562           content::Details<const extensions::InstalledExtensionInfo>(details)->
 563               extension);
 564       break;
 565     }
 566     case chrome::NOTIFICATION_EXTENSION_ENABLED: {
 567       AddExtensionEvent(EVENT_EXTENSION_ENABLE,
 568                         content::Details<Extension>(details).ptr());
 569       break;
 570     }
 571     case chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED: {
 572       const UnloadedExtensionInfo* info =
 573           content::Details<UnloadedExtensionInfo>(details).ptr();
 574
 575       // Check if the extension was unloaded because it was disabled.
 576       if (info->reason == UnloadedExtensionInfo::REASON_DISABLE) {
 577         AddExtensionEvent(EVENT_EXTENSION_DISABLE,
 578                           info->extension);
 579       }
 580       break;
 581     }
 582     case chrome::NOTIFICATION_CRX_INSTALLER_DONE: {
 583       const extensions::CrxInstaller* installer =
 584           content::Source<extensions::CrxInstaller>(source).ptr();
 585       const extensions::Extension* extension =
 586           content::Details<Extension>(details).ptr();
 587
 588       // Check if the reason for the install was due to a successful
 589       // extension update. |extension| is NULL in case of install failure.
 590       if (extension &&
 591           installer->install_cause() == extension_misc::INSTALL_CAUSE_UPDATE) {
 592         AddExtensionEvent(EVENT_EXTENSION_UPDATE, extension);
 593       }
 594       break;
 595     }
 596     case chrome::NOTIFICATION_EXTENSION_UNINSTALLED_DEPRECATED: {
 597       AddExtensionEvent(EVENT_EXTENSION_UNINSTALL,
 598                         content::Details<Extension>(details).ptr());
 599       break;
 600     }
 601     case content::NOTIFICATION_RENDER_WIDGET_HOST_HANG: {
 602       std::string url;
 603       content::RenderWidgetHost* widget =
 604           content::Source<content::RenderWidgetHost>(source).ptr();
 605       if (widget->IsRenderView()) {
 606         content::RenderViewHost* view = content::RenderViewHost::From(widget);
 607         MaybeGetURLFromRenderView(view, &url);
 608       }
 609       AddEvent(util::CreateRendererFailureEvent(base::Time::Now(),
 610                                                 EVENT_RENDERER_HANG,
 611                                                 url));
 612       break;
 613     }
 614     case content::NOTIFICATION_RENDERER_PROCESS_CLOSED: {
 615       AddRendererClosedEvent(
 616           content::Source<content::RenderProcessHost>(source).ptr(),
 617           *content::Details<content::RenderProcessHost::RendererClosedDetails>(
 618               details).ptr());
 619       break;
 620     }
 621     case chrome::NOTIFICATION_PROFILE_ADDED: {
 622       Profile* profile = content::Source<Profile>(source).ptr();
 623       if (profile->GetLastSessionExitType() == Profile::EXIT_CRASHED) {
 624         BrowserThread::PostBlockingPoolSequencedTask(
 625             Database::kDatabaseSequenceToken,
 626             FROM_HERE,
 627             base::Bind(
 628                 &PerformanceMonitor::AddUncleanExitEventOnBackgroundThread,
 629                 base::Unretained(this),
 630                 profile->GetDebugName()));
 631       }
 632       break;
 633     }
 634     case content::NOTIFICATION_LOAD_STOP: {
 635       const content::LoadNotificationDetails* load_details =
 636           content::Details<content::LoadNotificationDetails>(details).ptr();
 637       if (!load_details)
 638         break;
 639       BrowserThread::PostBlockingPoolSequencedTask(
 640           Database::kDatabaseSequenceToken,
 641           FROM_HERE,
 642           base::Bind(
 643               &PerformanceMonitor::AddMetricOnBackgroundThread,
 644               base::Unretained(this),
 645               Metric(METRIC_PAGE_LOAD_TIME,
 646                      base::Time::Now(),
 647                      static_cast<double>(
 648                          load_details->load_time.ToInternalValue()))));
 649       break;
 650     }
 651     default: {
 652       NOTREACHED();
 653       break;
 654     }
 655   }
 656 }
 657
 658 void PerformanceMonitor::AddExtensionEvent(EventType type,
 659                                               const Extension* extension) {
 660   DCHECK(type == EVENT_EXTENSION_INSTALL ||
 661          type == EVENT_EXTENSION_UNINSTALL ||
 662          type == EVENT_EXTENSION_UPDATE ||
 663          type == EVENT_EXTENSION_ENABLE ||
 664          type == EVENT_EXTENSION_DISABLE);
 665   AddEvent(util::CreateExtensionEvent(type,
 666                                       base::Time::Now(),
 667                                       extension->id(),
 668                                       extension->name(),
 669                                       extension->url().spec(),
 670                                       extension->location(),
 671                                       extension->VersionString(),
 672                                       extension->description()));
 673 }
 674
 675 void PerformanceMonitor::AddRendererClosedEvent(
 676     content::RenderProcessHost* host,
 677     const content::RenderProcessHost::RendererClosedDetails& details) {
 678   // We only care if this is an invalid termination.
 679   if (details.status == base::TERMINATION_STATUS_NORMAL_TERMINATION ||
 680       details.status == base::TERMINATION_STATUS_STILL_RUNNING)
 681     return;
 682
 683   // Determine the type of crash.
 684   EventType type =
 685       details.status == base::TERMINATION_STATUS_PROCESS_WAS_KILLED ?
 686       EVENT_RENDERER_KILLED : EVENT_RENDERER_CRASH;
 687
 688   // A RenderProcessHost may contain multiple render views - for each valid
 689   // render view, extract the url, and append it to the string, comma-separating
 690   // the entries.
 691   std::string url_list;
 692   scoped_ptr<content::RenderWidgetHostIterator> widgets(
 693       content::RenderWidgetHost::GetRenderWidgetHosts());
 694   while (content::RenderWidgetHost* widget = widgets->GetNextHost()) {
 695     if (widget->GetProcess()->GetID() != host->GetID())
 696       continue;
 697     if (!widget->IsRenderView())
 698       continue;
 699
 700     content::RenderViewHost* view = content::RenderViewHost::From(widget);
 701     std::string url;
 702     if (!MaybeGetURLFromRenderView(view, &url))
 703       continue;
 704
 705     if (!url_list.empty())
 706       url_list += ", ";
 707
 708     url_list += url;
 709   }
 710
 711   AddEvent(util::CreateRendererFailureEvent(base::Time::Now(), type, url_list));
 712 }
 713
 714 }  // namespace performance_monitor