Home | History | Annotate | Download | only in performance_monitor 
      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 "base/command_line.h"
      6 #include "base/files/file_path.h"
      7 #include "base/logging.h"
      8 #include "base/path_service.h"
      9 #include "base/strings/string_number_conversions.h"
     10 #include "base/threading/sequenced_worker_pool.h"
     11 #include "chrome/browser/browser_process.h"
     12 #include "chrome/browser/chrome_notification_types.h"
     13 #include "chrome/browser/extensions/extension_browsertest.h"
     14 #include "chrome/browser/extensions/extension_service.h"
     15 #include "chrome/browser/performance_monitor/constants.h"
     16 #include "chrome/browser/performance_monitor/database.h"
     17 #include "chrome/browser/performance_monitor/metric.h"
     18 #include "chrome/browser/performance_monitor/performance_monitor.h"
     19 #include "chrome/browser/prefs/session_startup_pref.h"
     20 #include "chrome/browser/profiles/profile.h"
     21 #include "chrome/browser/profiles/profile_manager.h"
     22 #include "chrome/browser/sessions/session_service.h"
     23 #include "chrome/browser/sessions/session_service_factory.h"
     24 #include "chrome/browser/sessions/session_service_test_helper.h"
     25 #include "chrome/browser/ui/browser.h"
     26 #include "chrome/browser/ui/browser_commands.h"
     27 #include "chrome/browser/ui/browser_navigator.h"
     28 #include "chrome/browser/ui/browser_window.h"
     29 #include "chrome/browser/ui/host_desktop.h"
     30 #include "chrome/browser/ui/tabs/tab_strip_model.h"
     31 #include "chrome/common/chrome_constants.h"
     32 #include "chrome/common/chrome_paths.h"
     33 #include "chrome/common/chrome_switches.h"
     34 #include "chrome/common/chrome_version_info.h"
     35 #include "chrome/common/url_constants.h"
     36 #include "chrome/test/base/ui_test_utils.h"
     37 #include "content/public/browser/notification_registrar.h"
     38 #include "content/public/browser/notification_service.h"
     39 #include "content/public/common/page_transition_types.h"
     40 #include "content/public/test/browser_test_utils.h"
     41 #include "content/public/test/test_navigation_observer.h"
     42 #include "content/public/test/test_utils.h"
     43 #include "extensions/common/extension.h"
     44 
     45 #if defined(OS_CHROMEOS)
     46 #include "chrome/browser/chromeos/login/users/user_manager.h"
     47 #include "chrome/browser/chromeos/profiles/profile_helper.h"
     48 #include "chromeos/chromeos_switches.h"
     49 #endif
     50 
     51 #if defined(OS_MACOSX)
     52 #include "base/mac/scoped_nsautorelease_pool.h"
     53 #endif
     54 
     55 using extensions::Extension;
     56 
     57 namespace performance_monitor {
     58 
     59 namespace {
     60 
     61 const base::TimeDelta kMaxStartupTime = base::TimeDelta::FromMinutes(3);
     62 
     63 #if defined(OS_CHROMEOS)
     64 // User account email and directory hash for secondary account for multi-profile
     65 // sensitive test cases.
     66 const char kSecondProfileAccount[] = "profile2 (at) test.com";
     67 const char kSecondProfileHash[] = "profile2";
     68 #endif
     69 
     70 // Helper struct to store the information of an extension; this is needed if the
     71 // pointer to the extension ever becomes invalid (e.g., if we uninstall the
     72 // extension).
     73 struct ExtensionBasicInfo {
     74   // Empty constructor for stl-container-happiness.
     75   ExtensionBasicInfo() {
     76   }
     77   explicit ExtensionBasicInfo(const Extension* extension)
     78       : description(extension->description()),
     79         id(extension->id()),
     80         name(extension->name()),
     81         url(extension->url().spec()),
     82         version(extension->VersionString()),
     83         location(extension->location()) {
     84   }
     85 
     86   std::string description;
     87   std::string id;
     88   std::string name;
     89   std::string url;
     90   std::string version;
     91   extensions::Manifest::Location location;
     92 };
     93 
     94 // Compare the fields of |extension| to those in |value|; this is a check to
     95 // make sure the extension data was recorded properly in the event.
     96 void ValidateExtensionInfo(const ExtensionBasicInfo extension,
     97                            const base::DictionaryValue* value) {
     98   std::string extension_description;
     99   std::string extension_id;
    100   std::string extension_name;
    101   std::string extension_url;
    102   std::string extension_version;
    103   int extension_location;
    104 
    105   ASSERT_TRUE(value->GetString("extensionDescription",
    106                                &extension_description));
    107   ASSERT_EQ(extension.description, extension_description);
    108   ASSERT_TRUE(value->GetString("extensionId", &extension_id));
    109   ASSERT_EQ(extension.id, extension_id);
    110   ASSERT_TRUE(value->GetString("extensionName", &extension_name));
    111   ASSERT_EQ(extension.name, extension_name);
    112   ASSERT_TRUE(value->GetString("extensionUrl", &extension_url));
    113   ASSERT_EQ(extension.url, extension_url);
    114   ASSERT_TRUE(value->GetString("extensionVersion", &extension_version));
    115   ASSERT_EQ(extension.version, extension_version);
    116   ASSERT_TRUE(value->GetInteger("extensionLocation", &extension_location));
    117   ASSERT_EQ(extension.location, extension_location);
    118 }
    119 
    120 // Verify that a particular event has the proper type.
    121 void CheckEventType(int expected_event_type, const linked_ptr<Event>& event) {
    122   int event_type = -1;
    123   ASSERT_TRUE(event->data()->GetInteger("eventType", &event_type));
    124   ASSERT_EQ(expected_event_type, event_type);
    125   ASSERT_EQ(expected_event_type, event->type());
    126 }
    127 
    128 // Verify that we received the proper number of events, checking the type of
    129 // each one.
    130 void CheckEventTypes(const std::vector<int>& expected_event_types,
    131                      const Database::EventVector& events) {
    132   ASSERT_EQ(expected_event_types.size(), events.size());
    133 
    134   for (size_t i = 0; i < expected_event_types.size(); ++i)
    135     CheckEventType(expected_event_types[i], events[i]);
    136 }
    137 
    138 // Check that we received the proper number of events, that each event is of the
    139 // proper type, and that each event recorded the proper information about the
    140 // extension.
    141 void CheckExtensionEvents(
    142     const std::vector<int>& expected_event_types,
    143     const Database::EventVector& events,
    144     const std::vector<ExtensionBasicInfo>& extension_infos) {
    145   CheckEventTypes(expected_event_types, events);
    146 
    147   for (size_t i = 0; i < expected_event_types.size(); ++i) {
    148     ValidateExtensionInfo(extension_infos[i], events[i]->data());
    149     int event_type;
    150     ASSERT_TRUE(events[i]->data()->GetInteger("eventType", &event_type));
    151     ASSERT_EQ(expected_event_types[i], event_type);
    152   }
    153 }
    154 
    155 }  // namespace
    156 
    157 class PerformanceMonitorBrowserTest : public ExtensionBrowserTest {
    158  public:
    159   virtual void SetUpOnMainThread() OVERRIDE {
    160     CHECK(db_dir_.CreateUniqueTempDir());
    161     performance_monitor_ = PerformanceMonitor::GetInstance();
    162     performance_monitor_->SetDatabasePath(db_dir_.path());
    163 
    164     // PerformanceMonitor's initialization process involves a significant
    165     // amount of thread-hopping between the UI thread and the background thread.
    166     // If we begin the tests prior to full initialization, we cannot predict
    167     // the behavior or mock synchronicity as we must. Wait for initialization
    168     // to complete fully before proceeding with the test.
    169     content::WindowedNotificationObserver windowed_observer(
    170         chrome::NOTIFICATION_PERFORMANCE_MONITOR_INITIALIZED,
    171         content::NotificationService::AllSources());
    172 
    173     // We stop the timer in charge of doing timed collections so that we can
    174     // enforce when, and how many times, we do these collections.
    175     performance_monitor_->disable_timer_autostart_for_testing_ = true;
    176     // Force metrics to be stored, regardless of switches used.
    177     performance_monitor_->database_logging_enabled_ = true;
    178     performance_monitor_->Initialize();
    179 
    180     windowed_observer.Wait();
    181   }
    182 
    183   // A handle for gathering statistics from the database, which must be done on
    184   // the background thread. Since we are testing, we can mock synchronicity with
    185   // FlushForTesting().
    186   void GatherStatistics() {
    187     performance_monitor_->next_collection_time_ = base::Time::Now();
    188     performance_monitor_->GatherMetricsMapOnUIThread();
    189 
    190     RunAllPendingInMessageLoop(content::BrowserThread::IO);
    191     content::BrowserThread::GetBlockingPool()->FlushForTesting();
    192   }
    193 
    194   void GetEventsOnBackgroundThread(Database::EventVector* events) {
    195     // base::Time is potentially flaky in that there is no guarantee that it
    196     // won't actually decrease between successive calls. If we call GetEvents
    197     // and the Database uses base::Time::Now() and gets a lesser time, then it
    198     // will return 0 events. Thus, we use a time that is guaranteed to be in the
    199     // future (for at least the next couple hundred thousand years).
    200     *events = performance_monitor_->database()->GetEvents(
    201         base::Time(), base::Time::FromInternalValue(kint64max));
    202   }
    203 
    204   // A handle for getting the events from the database, which must be done on
    205   // the background thread. Since we are testing, we can mock synchronicity
    206   // with FlushForTesting().
    207   Database::EventVector GetEvents() {
    208     // Ensure that any event insertions happen prior to getting events in order
    209     // to avoid race conditions.
    210     content::BrowserThread::GetBlockingPool()->FlushForTesting();
    211     content::RunAllPendingInMessageLoop();
    212 
    213     Database::EventVector events;
    214     content::BrowserThread::PostBlockingPoolSequencedTask(
    215         Database::kDatabaseSequenceToken,
    216         FROM_HERE,
    217         base::Bind(&PerformanceMonitorBrowserTest::GetEventsOnBackgroundThread,
    218                    base::Unretained(this),
    219                    &events));
    220 
    221     content::BrowserThread::GetBlockingPool()->FlushForTesting();
    222     return events;
    223   }
    224 
    225   void GetStatsOnBackgroundThread(Database::MetricVector* metrics,
    226                                   MetricType type) {
    227     *metrics = *performance_monitor_->database()->GetStatsForActivityAndMetric(
    228         type, base::Time(), base::Time::FromInternalValue(kint64max));
    229   }
    230 
    231   // A handle for getting statistics from the database (see previous comments on
    232   // GetEvents() and GetEventsOnBackgroundThread).
    233   Database::MetricVector GetStats(MetricType type) {
    234     content::BrowserThread::GetBlockingPool()->FlushForTesting();
    235     content::RunAllPendingInMessageLoop();
    236 
    237     Database::MetricVector metrics;
    238     content::BrowserThread::PostBlockingPoolSequencedTask(
    239         Database::kDatabaseSequenceToken,
    240         FROM_HERE,
    241         base::Bind(&PerformanceMonitorBrowserTest::GetStatsOnBackgroundThread,
    242                    base::Unretained(this),
    243                    &metrics,
    244                    type));
    245 
    246     content::BrowserThread::GetBlockingPool()->FlushForTesting();
    247     return metrics;
    248   }
    249 
    250   // A handle for inserting a state value into the database, which must be done
    251   // on the background thread. This is useful for mocking up a scenario in which
    252   // the database has prior data stored. We mock synchronicity with
    253   // FlushForTesting().
    254   void AddStateValue(const std::string& key, const std::string& value) {
    255     content::BrowserThread::PostBlockingPoolSequencedTask(
    256         Database::kDatabaseSequenceToken,
    257         FROM_HERE,
    258         base::Bind(base::IgnoreResult(&Database::AddStateValue),
    259                    base::Unretained(performance_monitor()->database()),
    260                    key,
    261                    value));
    262 
    263     content::BrowserThread::GetBlockingPool()->FlushForTesting();
    264   }
    265 
    266   // A handle for PerformanceMonitor::CheckForVersionUpdateOnBackgroundThread();
    267   // we mock synchronicity with FlushForTesting().
    268   void CheckForVersionUpdate() {
    269     content::BrowserThread::PostBlockingPoolSequencedTask(
    270         Database::kDatabaseSequenceToken,
    271         FROM_HERE,
    272         base::Bind(&PerformanceMonitor::CheckForVersionUpdateOnBackgroundThread,
    273                    base::Unretained(performance_monitor())));
    274 
    275     content::BrowserThread::GetBlockingPool()->FlushForTesting();
    276   }
    277 
    278   PerformanceMonitor* performance_monitor() const {
    279     return performance_monitor_;
    280   }
    281 
    282  protected:
    283   base::ScopedTempDir db_dir_;
    284   PerformanceMonitor* performance_monitor_;
    285 };
    286 
    287 class PerformanceMonitorUncleanExitBrowserTest
    288     : public PerformanceMonitorBrowserTest,
    289       public testing::WithParamInterface<bool> {
    290  public:
    291   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
    292     PerformanceMonitorBrowserTest::SetUpCommandLine(command_line);
    293 #if defined(OS_CHROMEOS)
    294     command_line->AppendSwitch(
    295         chromeos::switches::kIgnoreUserProfileMappingForTests);
    296 #endif
    297   }
    298 
    299   virtual bool SetUpUserDataDirectory() OVERRIDE {
    300     base::FilePath user_data_directory;
    301     PathService::Get(chrome::DIR_USER_DATA, &user_data_directory);
    302 
    303     // On CrOS, if we are "logged in" with the --login-profile switch,
    304     // the default profile will be different. We check if we are logged in, and,
    305     // if we are, we use that profile name instead. (Note: trybots will
    306     // typically be logged in with 'user'.)
    307 #if defined(OS_CHROMEOS)
    308     const CommandLine command_line = *CommandLine::ForCurrentProcess();
    309     if (command_line.HasSwitch(chromeos::switches::kLoginProfile)) {
    310       first_profile_name_ =
    311           command_line.GetSwitchValueASCII(chromeos::switches::kLoginProfile);
    312     } else {
    313       first_profile_name_ = chrome::kInitialProfile;
    314     }
    315 #else
    316     first_profile_name_ = chrome::kInitialProfile;
    317 #endif
    318 
    319     base::FilePath first_profile =
    320         user_data_directory.AppendASCII(first_profile_name_);
    321     CHECK(base::CreateDirectory(first_profile));
    322 
    323     base::FilePath stock_prefs_file;
    324     PathService::Get(chrome::DIR_TEST_DATA, &stock_prefs_file);
    325     stock_prefs_file = stock_prefs_file.AppendASCII("performance_monitor")
    326                                        .AppendASCII("unclean_exit_prefs");
    327     CHECK(base::PathExists(stock_prefs_file));
    328 
    329     base::FilePath first_profile_prefs_file =
    330         first_profile.Append(chrome::kPreferencesFilename);
    331     CHECK(base::CopyFile(stock_prefs_file, first_profile_prefs_file));
    332     CHECK(base::PathExists(first_profile_prefs_file));
    333 
    334     second_profile_name_ =
    335         std::string(chrome::kMultiProfileDirPrefix)
    336         .append(base::IntToString(1));
    337 #if defined(OS_CHROMEOS)
    338     if (GetParam()) {
    339       second_profile_name_ = chromeos::ProfileHelper::GetUserProfileDir(
    340           kSecondProfileHash).BaseName().value();
    341     }
    342 #endif
    343 
    344     base::FilePath second_profile =
    345         user_data_directory.AppendASCII(second_profile_name_);
    346     CHECK(base::CreateDirectory(second_profile));
    347 
    348     base::FilePath second_profile_prefs_file =
    349         second_profile.Append(chrome::kPreferencesFilename);
    350     CHECK(base::CopyFile(stock_prefs_file, second_profile_prefs_file));
    351     CHECK(base::PathExists(second_profile_prefs_file));
    352 
    353     return true;
    354   }
    355 
    356 #if defined(OS_CHROMEOS)
    357   virtual void AddSecondUserAccount() {
    358     // Add second user account for multi-profile test.
    359     if (GetParam()) {
    360       chromeos::UserManager::Get()->UserLoggedIn(kSecondProfileAccount,
    361                                                  kSecondProfileHash,
    362                                                  false);
    363     }
    364   }
    365 #endif
    366 
    367  protected:
    368   std::string first_profile_name_;
    369   std::string second_profile_name_;
    370 };
    371 
    372 class PerformanceMonitorSessionRestoreBrowserTest
    373     : public PerformanceMonitorBrowserTest {
    374  public:
    375   virtual void SetUpOnMainThread() OVERRIDE {
    376     SessionStartupPref pref(SessionStartupPref::LAST);
    377     SessionStartupPref::SetStartupPref(browser()->profile(), pref);
    378 #if defined(OS_CHROMEOS) || defined (OS_MACOSX)
    379     // Undo the effect of kBrowserAliveWithNoWindows in defaults.cc so that we
    380     // can get these test to work without quitting.
    381     SessionServiceTestHelper helper(
    382         SessionServiceFactory::GetForProfile(browser()->profile()));
    383     helper.SetForceBrowserNotAliveWithNoWindows(true);
    384     helper.ReleaseService();
    385 #endif
    386 
    387     PerformanceMonitorBrowserTest::SetUpOnMainThread();
    388   }
    389 
    390   Browser* QuitBrowserAndRestore(Browser* browser, int expected_tab_count) {
    391     Profile* profile = browser->profile();
    392 
    393     // Close the browser.
    394     g_browser_process->AddRefModule();
    395     content::WindowedNotificationObserver observer(
    396         chrome::NOTIFICATION_BROWSER_CLOSED,
    397         content::NotificationService::AllSources());
    398     browser->window()->Close();
    399 #if defined(OS_MACOSX)
    400     // BrowserWindowController depends on the auto release pool being recycled
    401     // in the message loop to delete itself, which frees the Browser object
    402     // which fires this event.
    403     AutoreleasePool()->Recycle();
    404 #endif
    405     observer.Wait();
    406 
    407     // Create a new window, which should trigger session restore.
    408     content::TestNavigationObserver restore_observer(NULL, expected_tab_count);
    409     restore_observer.StartWatchingNewWebContents();
    410     ui_test_utils::BrowserAddedObserver window_observer;
    411     chrome::NewEmptyWindow(profile, chrome::GetActiveDesktop());
    412     Browser* new_browser = window_observer.WaitForSingleNewBrowser();
    413     restore_observer.Wait();
    414     g_browser_process->ReleaseModule();
    415 
    416     return new_browser;
    417   }
    418 };
    419 
    420 // Test that PerformanceMonitor will correctly record an extension installation
    421 // event.
    422 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest, InstallExtensionEvent) {
    423   base::FilePath extension_path;
    424   PathService::Get(chrome::DIR_TEST_DATA, &extension_path);
    425   extension_path = extension_path.AppendASCII("performance_monitor")
    426                                  .AppendASCII("extensions")
    427                                  .AppendASCII("simple_extension_v1");
    428   const Extension* extension = LoadExtension(extension_path);
    429 
    430   std::vector<ExtensionBasicInfo> extension_infos;
    431   extension_infos.push_back(ExtensionBasicInfo(extension));
    432 
    433   std::vector<int> expected_event_types;
    434   expected_event_types.push_back(EVENT_EXTENSION_INSTALL);
    435 
    436   Database::EventVector events = GetEvents();
    437   CheckExtensionEvents(expected_event_types, events, extension_infos);
    438 }
    439 
    440 // Test that PerformanceMonitor will correctly record events as an extension is
    441 // disabled and enabled.
    442 // Test is falky, see http://crbug.com/157980
    443 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest,
    444                        DISABLED_DisableAndEnableExtensionEvent) {
    445   const int kNumEvents = 3;
    446 
    447   base::FilePath extension_path;
    448   PathService::Get(chrome::DIR_TEST_DATA, &extension_path);
    449   extension_path = extension_path.AppendASCII("performance_monitor")
    450                                  .AppendASCII("extensions")
    451                                  .AppendASCII("simple_extension_v1");
    452   const Extension* extension = LoadExtension(extension_path);
    453 
    454   DisableExtension(extension->id());
    455   EnableExtension(extension->id());
    456 
    457   std::vector<ExtensionBasicInfo> extension_infos;
    458   // There will be three events in all, each pertaining to the same extension:
    459   //   Extension Install
    460   //   Extension Disable
    461   //   Extension Enable
    462   for (int i = 0; i < kNumEvents; ++i)
    463     extension_infos.push_back(ExtensionBasicInfo(extension));
    464 
    465   std::vector<int> expected_event_types;
    466   expected_event_types.push_back(EVENT_EXTENSION_INSTALL);
    467   expected_event_types.push_back(EVENT_EXTENSION_DISABLE);
    468   expected_event_types.push_back(EVENT_EXTENSION_ENABLE);
    469 
    470   Database::EventVector events = GetEvents();
    471   CheckExtensionEvents(expected_event_types, events, extension_infos);
    472 }
    473 
    474 // Test that PerformanceMonitor correctly records an extension update event.
    475 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest, UpdateExtensionEvent) {
    476   base::ScopedTempDir temp_dir;
    477   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
    478 
    479   base::FilePath test_data_dir;
    480   PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir);
    481   test_data_dir = test_data_dir.AppendASCII("performance_monitor")
    482                                .AppendASCII("extensions");
    483 
    484   // We need two versions of the same extension.
    485   base::FilePath pem_path = test_data_dir.AppendASCII("simple_extension.pem");
    486   base::FilePath path_v1_ = PackExtensionWithOptions(
    487       test_data_dir.AppendASCII("simple_extension_v1"),
    488       temp_dir.path().AppendASCII("simple_extension1.crx"),
    489       pem_path,
    490       base::FilePath());
    491   base::FilePath path_v2_ = PackExtensionWithOptions(
    492       test_data_dir.AppendASCII("simple_extension_v2"),
    493       temp_dir.path().AppendASCII("simple_extension2.crx"),
    494       pem_path,
    495       base::FilePath());
    496 
    497   const extensions::Extension* extension = InstallExtension(path_v1_, 1);
    498 
    499   std::vector<ExtensionBasicInfo> extension_infos;
    500   extension_infos.push_back(ExtensionBasicInfo(extension));
    501 
    502   ExtensionService* extension_service =
    503       browser()->profile()->GetExtensionService();
    504 
    505   extensions::CrxInstaller* crx_installer = NULL;
    506 
    507   // Create an observer to wait for the update to finish.
    508   content::WindowedNotificationObserver windowed_observer(
    509       chrome::NOTIFICATION_CRX_INSTALLER_DONE,
    510       content::Source<extensions::CrxInstaller>(crx_installer));
    511   ASSERT_TRUE(extension_service->
    512       UpdateExtension(extension->id(), path_v2_, true, &crx_installer));
    513   windowed_observer.Wait();
    514 
    515   extension = extension_service->GetExtensionById(
    516       extension_infos[0].id, false); // don't include disabled extensions.
    517 
    518   // The total series of events for this process will be:
    519   //   Extension Install - install version 1
    520   //   Extension Install - install version 2
    521   //   Extension Update  - signal the udate to version 2
    522   // We push back the corresponding ExtensionBasicInfos.
    523   extension_infos.push_back(ExtensionBasicInfo(extension));
    524   extension_infos.push_back(extension_infos[1]);
    525 
    526   std::vector<int> expected_event_types;
    527   expected_event_types.push_back(EVENT_EXTENSION_INSTALL);
    528   expected_event_types.push_back(EVENT_EXTENSION_INSTALL);
    529   expected_event_types.push_back(EVENT_EXTENSION_UPDATE);
    530 
    531   Database::EventVector events = GetEvents();
    532 
    533   CheckExtensionEvents(expected_event_types, events, extension_infos);
    534 }
    535 
    536 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest, UninstallExtensionEvent) {
    537   const int kNumEvents = 2;
    538   base::FilePath extension_path;
    539   PathService::Get(chrome::DIR_TEST_DATA, &extension_path);
    540   extension_path = extension_path.AppendASCII("performance_monitor")
    541                                  .AppendASCII("extensions")
    542                                  .AppendASCII("simple_extension_v1");
    543   const Extension* extension = LoadExtension(extension_path);
    544 
    545   std::vector<ExtensionBasicInfo> extension_infos;
    546   // There will be two events, both pertaining to the same extension:
    547   //   Extension Install
    548   //   Extension Uninstall
    549   for (int i = 0; i < kNumEvents; ++i)
    550     extension_infos.push_back(ExtensionBasicInfo(extension));
    551 
    552   UninstallExtension(extension->id());
    553 
    554   std::vector<int> expected_event_types;
    555   expected_event_types.push_back(EVENT_EXTENSION_INSTALL);
    556   expected_event_types.push_back(EVENT_EXTENSION_UNINSTALL);
    557 
    558   Database::EventVector events = GetEvents();
    559 
    560   CheckExtensionEvents(expected_event_types, events, extension_infos);
    561 }
    562 
    563 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest, NewVersionEvent) {
    564   const char kOldVersion[] = "0.0";
    565 
    566   // The version in the database right now will be the current version of chrome
    567   // (gathered at initialization of PerformanceMonitor). Replace this with an
    568   // older version so an event is generated.
    569   AddStateValue(kStateChromeVersion, kOldVersion);
    570 
    571   CheckForVersionUpdate();
    572 
    573   chrome::VersionInfo version;
    574   ASSERT_TRUE(version.is_valid());
    575   std::string version_string = version.Version();
    576 
    577   Database::EventVector events = GetEvents();
    578   ASSERT_EQ(1u, events.size());
    579   ASSERT_EQ(EVENT_CHROME_UPDATE, events[0]->type());
    580 
    581   const base::DictionaryValue* value;
    582   ASSERT_TRUE(events[0]->data()->GetAsDictionary(&value));
    583 
    584   std::string previous_version;
    585   std::string current_version;
    586 
    587   ASSERT_TRUE(value->GetString("previousVersion", &previous_version));
    588   ASSERT_EQ(kOldVersion, previous_version);
    589   ASSERT_TRUE(value->GetString("currentVersion", &current_version));
    590   ASSERT_EQ(version_string, current_version);
    591 }
    592 
    593 // crbug.com/160502
    594 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest,
    595                        DISABLED_GatherStatistics) {
    596   GatherStatistics();
    597 
    598   // No stats should be recorded for this CPUUsage because this was the first
    599   // call to GatherStatistics.
    600   Database::MetricVector stats = GetStats(METRIC_CPU_USAGE);
    601   ASSERT_EQ(0u, stats.size());
    602 
    603   stats = GetStats(METRIC_PRIVATE_MEMORY_USAGE);
    604   ASSERT_EQ(1u, stats.size());
    605   EXPECT_GT(stats[0].value, 0);
    606 
    607   stats = GetStats(METRIC_SHARED_MEMORY_USAGE);
    608   ASSERT_EQ(1u, stats.size());
    609   EXPECT_GT(stats[0].value, 0);
    610 
    611   // Open new tabs to incur CPU usage.
    612   for (int i = 0; i < 10; ++i) {
    613     chrome::NavigateParams params(
    614         browser(), ui_test_utils::GetTestUrl(
    615                        base::FilePath(base::FilePath::kCurrentDirectory),
    616                        base::FilePath(FILE_PATH_LITERAL("title1.html"))),
    617         content::PAGE_TRANSITION_LINK);
    618     params.disposition = NEW_BACKGROUND_TAB;
    619     ui_test_utils::NavigateToURL(&params);
    620   }
    621   GatherStatistics();
    622 
    623   // One CPUUsage stat should exist now.
    624   stats = GetStats(METRIC_CPU_USAGE);
    625   ASSERT_EQ(1u, stats.size());
    626   EXPECT_GT(stats[0].value, 0);
    627 
    628   stats = GetStats(METRIC_PRIVATE_MEMORY_USAGE);
    629   ASSERT_EQ(2u, stats.size());
    630   EXPECT_GT(stats[1].value, 0);
    631 
    632   stats = GetStats(METRIC_SHARED_MEMORY_USAGE);
    633   ASSERT_EQ(2u, stats.size());
    634   EXPECT_GT(stats[1].value, 0);
    635 }
    636 
    637 // Disabled on other platforms because of flakiness: http://crbug.com/159172.
    638 #if !defined(OS_WIN)
    639 // Disabled on Windows due to a bug where Windows will return a normal exit
    640 // code in the testing environment, even if the process died (this is not the
    641 // case when hand-testing). This code can be traced to MSDN functions in
    642 // base::GetTerminationStatus(), so there's not much we can do.
    643 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest,
    644                        DISABLED_RendererKilledEvent) {
    645   content::CrashTab(browser()->tab_strip_model()->GetActiveWebContents());
    646 
    647   Database::EventVector events = GetEvents();
    648 
    649   ASSERT_EQ(1u, events.size());
    650   CheckEventType(EVENT_RENDERER_KILLED, events[0]);
    651 
    652   // Check the url - since we never went anywhere, this should be about:blank.
    653   std::string url;
    654   ASSERT_TRUE(events[0]->data()->GetString("url", &url));
    655   ASSERT_EQ("about:blank", url);
    656 }
    657 #endif  // !defined(OS_WIN)
    658 
    659 // TODO(jam): http://crbug.com/350550
    660 #if !(defined(OS_CHROMEOS) && defined(ADDRESS_SANITIZER))
    661 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest, RendererCrashEvent) {
    662   content::RenderProcessHostWatcher observer(
    663       browser()->tab_strip_model()->GetActiveWebContents(),
    664       content::RenderProcessHostWatcher::WATCH_FOR_PROCESS_EXIT);
    665 
    666   ui_test_utils::NavigateToURL(browser(), GURL(content::kChromeUICrashURL));
    667 
    668   observer.Wait();
    669 
    670   Database::EventVector events = GetEvents();
    671   ASSERT_EQ(1u, events.size());
    672 
    673   CheckEventType(EVENT_RENDERER_CRASH, events[0]);
    674 
    675   std::string url;
    676   ASSERT_TRUE(events[0]->data()->GetString("url", &url));
    677   ASSERT_EQ("chrome://crash/", url);
    678 }
    679 #endif
    680 
    681 IN_PROC_BROWSER_TEST_P(PerformanceMonitorUncleanExitBrowserTest,
    682                        OneProfileUncleanExit) {
    683   // Initialize the database value (if there's no value in the database, it
    684   // can't determine the last active time of the profile, and doesn't insert
    685   // the event).
    686   const std::string time = "12985807272597591";
    687   AddStateValue(kStateProfilePrefix + first_profile_name_, time);
    688 
    689   performance_monitor()->CheckForUncleanExits();
    690   content::RunAllPendingInMessageLoop();
    691 
    692   Database::EventVector events = GetEvents();
    693 
    694   const size_t kNumEvents = 1;
    695   ASSERT_EQ(kNumEvents, events.size());
    696 
    697   CheckEventType(EVENT_UNCLEAN_EXIT, events[0]);
    698 
    699   std::string event_profile;
    700   ASSERT_TRUE(events[0]->data()->GetString("profileName", &event_profile));
    701   ASSERT_EQ(first_profile_name_, event_profile);
    702 }
    703 
    704 IN_PROC_BROWSER_TEST_P(PerformanceMonitorUncleanExitBrowserTest,
    705                        TwoProfileUncleanExit) {
    706 #if defined(OS_CHROMEOS)
    707   AddSecondUserAccount();
    708 #endif
    709 
    710   base::FilePath second_profile_path;
    711   PathService::Get(chrome::DIR_USER_DATA, &second_profile_path);
    712   second_profile_path = second_profile_path.AppendASCII(second_profile_name_);
    713 
    714   const std::string time1 = "12985807272597591";
    715   const std::string time2 = "12985807272599918";
    716 
    717   // Initialize the database.
    718   AddStateValue(kStateProfilePrefix + first_profile_name_, time1);
    719   AddStateValue(kStateProfilePrefix + second_profile_name_, time2);
    720 
    721   performance_monitor()->CheckForUncleanExits();
    722   content::RunAllPendingInMessageLoop();
    723 
    724   // Load the second profile, which has also exited uncleanly. Note that since
    725   // the second profile is new, component extensions will be installed as part
    726   // of the browser startup for that profile, generating extra events.
    727   g_browser_process->profile_manager()->GetProfile(second_profile_path);
    728   content::RunAllPendingInMessageLoop();
    729 
    730   Database::EventVector events = GetEvents();
    731 
    732   const size_t kNumUncleanExitEvents = 2;
    733   size_t num_unclean_exit_events = 0;
    734   for (size_t i = 0; i < events.size(); ++i) {
    735     int event_type = -1;
    736     if (events[i]->data()->GetInteger("eventType", &event_type) &&
    737         event_type == EVENT_EXTENSION_INSTALL) {
    738       continue;
    739     }
    740     CheckEventType(EVENT_UNCLEAN_EXIT, events[i]);
    741     ++num_unclean_exit_events;
    742   }
    743   ASSERT_EQ(kNumUncleanExitEvents, num_unclean_exit_events);
    744 
    745   std::string event_profile;
    746   ASSERT_TRUE(events[0]->data()->GetString("profileName", &event_profile));
    747   ASSERT_EQ(first_profile_name_, event_profile);
    748 
    749   ASSERT_TRUE(events[1]->data()->GetString("profileName", &event_profile));
    750   ASSERT_EQ(second_profile_name_, event_profile);
    751 }
    752 
    753 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest, StartupTime) {
    754   Database::MetricVector metrics = GetStats(METRIC_TEST_STARTUP_TIME);
    755 
    756   ASSERT_EQ(1u, metrics.size());
    757   ASSERT_LT(metrics[0].value, kMaxStartupTime.ToInternalValue());
    758 }
    759 
    760 IN_PROC_BROWSER_TEST_F(PerformanceMonitorSessionRestoreBrowserTest,
    761                        StartupWithSessionRestore) {
    762   ui_test_utils::NavigateToURL(
    763       browser(), ui_test_utils::GetTestUrl(
    764                      base::FilePath(base::FilePath::kCurrentDirectory),
    765                      base::FilePath(FILE_PATH_LITERAL("title1.html"))));
    766 
    767   QuitBrowserAndRestore(browser(), 1);
    768 
    769   Database::MetricVector metrics = GetStats(METRIC_TEST_STARTUP_TIME);
    770   ASSERT_EQ(1u, metrics.size());
    771   ASSERT_LT(metrics[0].value, kMaxStartupTime.ToInternalValue());
    772 
    773   metrics = GetStats(METRIC_SESSION_RESTORE_TIME);
    774   ASSERT_EQ(1u, metrics.size());
    775   ASSERT_LT(metrics[0].value, kMaxStartupTime.ToInternalValue());
    776 }
    777 
    778 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest, PageLoadTime) {
    779   const base::TimeDelta kMaxLoadTime = base::TimeDelta::FromSeconds(30);
    780 
    781   ui_test_utils::NavigateToURL(
    782       browser(), ui_test_utils::GetTestUrl(
    783                      base::FilePath(base::FilePath::kCurrentDirectory),
    784                      base::FilePath(FILE_PATH_LITERAL("title1.html"))));
    785 
    786   ui_test_utils::NavigateToURL(
    787       browser(), ui_test_utils::GetTestUrl(
    788                      base::FilePath(base::FilePath::kCurrentDirectory),
    789                      base::FilePath(FILE_PATH_LITERAL("title1.html"))));
    790 
    791   Database::MetricVector metrics = GetStats(METRIC_PAGE_LOAD_TIME);
    792 
    793   ASSERT_EQ(2u, metrics.size());
    794   ASSERT_LT(metrics[0].value, kMaxLoadTime.ToInternalValue());
    795   ASSERT_LT(metrics[1].value, kMaxLoadTime.ToInternalValue());
    796 }
    797 
    798 IN_PROC_BROWSER_TEST_F(PerformanceMonitorBrowserTest, NetworkBytesRead) {
    799   base::FilePath test_dir;
    800   PathService::Get(chrome::DIR_TEST_DATA, &test_dir);
    801 
    802   int64 page1_size = 0;
    803   ASSERT_TRUE(base::GetFileSize(test_dir.AppendASCII("title1.html"),
    804                                 &page1_size));
    805 
    806   int64 page2_size = 0;
    807   ASSERT_TRUE(base::GetFileSize(test_dir.AppendASCII("title2.html"),
    808                                 &page2_size));
    809 
    810   ASSERT_TRUE(test_server()->Start());
    811 
    812   ui_test_utils::NavigateToURL(
    813       browser(),
    814       test_server()->GetURL(std::string("files/").append("title1.html")));
    815 
    816   GatherStatistics();
    817 
    818   Database::MetricVector metrics = GetStats(METRIC_NETWORK_BYTES_READ);
    819   ASSERT_EQ(1u, metrics.size());
    820   // Since these pages are read over the "network" (actually the test_server),
    821   // some extraneous information is carried along, and the best check we can do
    822   // is for greater than or equal to.
    823   EXPECT_GE(metrics[0].value, page1_size);
    824 
    825   ui_test_utils::NavigateToURL(
    826       browser(),
    827       test_server()->GetURL(std::string("files/").append("title2.html")));
    828 
    829   GatherStatistics();
    830 
    831   metrics = GetStats(METRIC_NETWORK_BYTES_READ);
    832   ASSERT_EQ(2u, metrics.size());
    833   EXPECT_GE(metrics[1].value, page1_size + page2_size);
    834 }
    835 
    836 INSTANTIATE_TEST_CASE_P(PerformanceMonitorUncleanExitBrowserTestInstantiation,
    837                         PerformanceMonitorUncleanExitBrowserTest,
    838                         testing::Bool());
    839 
    840 }  // namespace performance_monitor
    841