chrome/browser/power/process_power_collector_unittest.cc

   1 // Copyright 2014 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/power/process_power_collector.h"
   6
   7 #include "chrome/browser/profiles/profile_manager.h"
   8 #include "chrome/browser/ui/apps/chrome_app_delegate.h"
   9 #include "chrome/browser/ui/browser_commands.h"
  10 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  11 #include "chrome/test/base/browser_with_test_window_test.h"
  12 #include "chrome/test/base/testing_browser_process.h"
  13 #include "chrome/test/base/testing_profile_manager.h"
  14 #include "components/power/origin_power_map.h"
  15 #include "components/power/origin_power_map_factory.h"
  16 #include "content/public/browser/site_instance.h"
  17 #include "content/public/test/browser_test_utils.h"
  18 #include "content/public/test/mock_render_process_host.h"
  19 #include "extensions/browser/app_window/app_window_contents.h"
  20 #include "extensions/browser/app_window/app_window_registry.h"
  21 #include "extensions/browser/app_window/apps_client.h"
  22 #include "extensions/browser/app_window/native_app_window.h"
  23 #include "extensions/common/extension.h"
  24 #include "testing/gtest/include/gtest/gtest.h"
  25 #include "url/gurl.h"
  26
  27 #if defined(OS_CHROMEOS)
  28 #include "chromeos/dbus/power_manager/power_supply_properties.pb.h"
  29 #endif
  30
  31 using power::OriginPowerMap;
  32 using power::OriginPowerMapFactory;
  33
  34 class BrowserProcessPowerTest : public BrowserWithTestWindowTest {
  35  public:
  36   BrowserProcessPowerTest() {}
  37   virtual ~BrowserProcessPowerTest() {}
  38
  39   virtual void SetUp() OVERRIDE {
  40     BrowserWithTestWindowTest::SetUp();
  41     collector.reset(new ProcessPowerCollector);
  42
  43 #if defined(OS_CHROMEOS)
  44     power_manager::PowerSupplyProperties prop;
  45     prop.set_external_power(power_manager::PowerSupplyProperties::AC);
  46     prop.set_battery_state(power_manager::PowerSupplyProperties::DISCHARGING);
  47     prop.set_battery_percent(20.00);
  48     prop.set_battery_discharge_rate(1);
  49     collector->PowerChanged(prop);
  50 #endif
  51
  52     profile_manager_.reset(
  53         new TestingProfileManager(TestingBrowserProcess::GetGlobal()));
  54     ASSERT_TRUE(profile_manager_->SetUp());
  55   }
  56
  57   virtual void TearDown() OVERRIDE {
  58     collector.reset();
  59     BrowserWithTestWindowTest::TearDown();
  60   }
  61
  62   // Mocks out CPU usage for all processes as |value| percent.
  63   double ReturnCpuAsConstant(double value, base::ProcessHandle handle) {
  64     return value;
  65   }
  66
  67  protected:
  68   content::MockRenderProcessHost* GetProcess(Browser* browser) {
  69     return static_cast<content::MockRenderProcessHost*>(
  70         browser->tab_strip_model()
  71             ->GetActiveWebContents()
  72             ->GetRenderViewHost()
  73             ->GetProcess());
  74   }
  75
  76   scoped_ptr<base::ProcessHandle> MakeProcessHandle(int process_id) {
  77     scoped_ptr<base::ProcessHandle> proc_handle(new base::ProcessHandle(
  78 #if defined(OS_WIN)
  79         reinterpret_cast<HANDLE>(process_id))
  80 #else
  81         process_id)
  82 #endif
  83                                                 );
  84     return proc_handle.Pass();
  85   }
  86
  87   scoped_ptr<ProcessPowerCollector> collector;
  88   scoped_ptr<TestingProfileManager> profile_manager_;
  89 };
  90
  91 class TestAppWindowContents : public extensions::AppWindowContents {
  92  public:
  93   explicit TestAppWindowContents(content::WebContents* web_contents)
  94       : web_contents_(web_contents) {}
  95
  96   // apps:AppWindowContents
  97   virtual void Initialize(content::BrowserContext* context,
  98                           const GURL& url) OVERRIDE {}
  99   virtual void LoadContents(int32 creator_process_id) OVERRIDE {}
 100   virtual void NativeWindowChanged(
 101       extensions::NativeAppWindow* native_app_window) OVERRIDE {}
 102   virtual void NativeWindowClosed() OVERRIDE {}
 103   virtual void DispatchWindowShownForTests() const OVERRIDE {}
 104   virtual content::WebContents* GetWebContents() const OVERRIDE {
 105     return web_contents_.get();
 106   }
 107
 108  private:
 109   scoped_ptr<content::WebContents> web_contents_;
 110 };
 111
 112 TEST_F(BrowserProcessPowerTest, NoSite) {
 113   collector->UpdatePowerConsumptionForTesting();
 114   EXPECT_EQ(0u, collector->metrics_map_for_testing()->size());
 115 }
 116
 117 TEST_F(BrowserProcessPowerTest, OneSite) {
 118   GURL url("http://www.google.com");
 119   AddTab(browser(), url);
 120   collector->UpdatePowerConsumptionForTesting();
 121   ProcessPowerCollector::ProcessMetricsMap* metrics_map =
 122       collector->metrics_map_for_testing();
 123   EXPECT_EQ(1u, metrics_map->size());
 124
 125   // Create fake process numbers.
 126   GetProcess(browser())->SetProcessHandle(MakeProcessHandle(1).Pass());
 127
 128   OriginPowerMap* origin_power_map =
 129       OriginPowerMapFactory::GetForBrowserContext(profile());
 130   EXPECT_EQ(0, origin_power_map->GetPowerForOrigin(url));
 131
 132   collector->set_cpu_usage_callback_for_testing(
 133       base::Bind(&BrowserProcessPowerTest::ReturnCpuAsConstant,
 134                  base::Unretained(this),
 135                  5));
 136   EXPECT_DOUBLE_EQ(5, collector->UpdatePowerConsumptionForTesting());
 137   EXPECT_EQ(100, origin_power_map->GetPowerForOrigin(url));
 138 }
 139
 140 TEST_F(BrowserProcessPowerTest, MultipleSites) {
 141   Browser::CreateParams native_params(profile(),
 142                                       chrome::HOST_DESKTOP_TYPE_NATIVE);
 143   GURL url1("http://www.google.com");
 144   GURL url2("http://www.example.com");
 145   GURL url3("https://www.google.com");
 146   scoped_ptr<Browser> browser2(
 147       chrome::CreateBrowserWithTestWindowForParams(&native_params));
 148   scoped_ptr<Browser> browser3(
 149       chrome::CreateBrowserWithTestWindowForParams(&native_params));
 150   AddTab(browser(), url1);
 151   AddTab(browser2.get(), url2);
 152   AddTab(browser3.get(), url3);
 153
 154   // Create fake process numbers.
 155   GetProcess(browser())->SetProcessHandle(MakeProcessHandle(1).Pass());
 156   GetProcess(browser2.get())->SetProcessHandle(MakeProcessHandle(2).Pass());
 157   GetProcess(browser3.get())->SetProcessHandle(MakeProcessHandle(3).Pass());
 158
 159   collector->UpdatePowerConsumptionForTesting();
 160   ProcessPowerCollector::ProcessMetricsMap* metrics_map =
 161       collector->metrics_map_for_testing();
 162   EXPECT_EQ(3u, metrics_map->size());
 163
 164   // Since all handlers are uninitialized, this should be 0.
 165   EXPECT_DOUBLE_EQ(0, collector->UpdatePowerConsumptionForTesting());
 166   OriginPowerMap* origin_power_map =
 167       OriginPowerMapFactory::GetForBrowserContext(profile());
 168   EXPECT_EQ(0, origin_power_map->GetPowerForOrigin(url1));
 169   EXPECT_EQ(0, origin_power_map->GetPowerForOrigin(url2));
 170   EXPECT_EQ(0, origin_power_map->GetPowerForOrigin(url3));
 171
 172   collector->set_cpu_usage_callback_for_testing(
 173       base::Bind(&BrowserProcessPowerTest::ReturnCpuAsConstant,
 174                  base::Unretained(this),
 175                  5));
 176   EXPECT_DOUBLE_EQ(15, collector->UpdatePowerConsumptionForTesting());
 177   EXPECT_EQ(33, origin_power_map->GetPowerForOrigin(url1));
 178   EXPECT_EQ(33, origin_power_map->GetPowerForOrigin(url2));
 179   EXPECT_EQ(33, origin_power_map->GetPowerForOrigin(url3));
 180
 181   // Close some tabs and verify that they are removed from the metrics map.
 182   chrome::CloseTab(browser2.get());
 183   chrome::CloseTab(browser3.get());
 184
 185   collector->UpdatePowerConsumptionForTesting();
 186   EXPECT_EQ(1u, metrics_map->size());
 187 }
 188
 189 TEST_F(BrowserProcessPowerTest, IncognitoDoesntRecordPowerUsage) {
 190   Browser::CreateParams native_params(profile()->GetOffTheRecordProfile(),
 191                                       chrome::HOST_DESKTOP_TYPE_NATIVE);
 192   scoped_ptr<Browser> incognito_browser(
 193       chrome::CreateBrowserWithTestWindowForParams(&native_params));
 194   GURL url("http://www.google.com");
 195   AddTab(browser(), url);
 196
 197   GURL hidden_url("http://foo.com");
 198   AddTab(incognito_browser.get(), hidden_url);
 199
 200   // Create fake process numbers.
 201   GetProcess(browser())->SetProcessHandle(MakeProcessHandle(1).Pass());
 202   GetProcess(incognito_browser.get())
 203       ->SetProcessHandle(MakeProcessHandle(2).Pass());
 204
 205   EXPECT_DOUBLE_EQ(0, collector->UpdatePowerConsumptionForTesting());
 206   ProcessPowerCollector::ProcessMetricsMap* metrics_map =
 207       collector->metrics_map_for_testing();
 208   EXPECT_EQ(1u, metrics_map->size());
 209
 210   OriginPowerMap* origin_power_map =
 211       OriginPowerMapFactory::GetForBrowserContext(profile());
 212   EXPECT_EQ(0, origin_power_map->GetPowerForOrigin(url));
 213
 214   collector->set_cpu_usage_callback_for_testing(
 215       base::Bind(&BrowserProcessPowerTest::ReturnCpuAsConstant,
 216                  base::Unretained(this),
 217                  5));
 218   EXPECT_DOUBLE_EQ(5, collector->UpdatePowerConsumptionForTesting());
 219
 220   // Verify that the incognito data was not stored.
 221   EXPECT_EQ(100, origin_power_map->GetPowerForOrigin(url));
 222   EXPECT_EQ(0, origin_power_map->GetPowerForOrigin(hidden_url));
 223
 224   chrome::CloseTab(incognito_browser.get());
 225 }
 226
 227 TEST_F(BrowserProcessPowerTest, MultipleProfilesRecordSeparately) {
 228   scoped_ptr<Profile> other_profile(CreateProfile());
 229   Browser::CreateParams native_params(other_profile.get(),
 230                                       chrome::HOST_DESKTOP_TYPE_NATIVE);
 231   scoped_ptr<Browser> other_user(
 232       chrome::CreateBrowserWithTestWindowForParams(&native_params));
 233
 234   GURL url("http://www.google.com");
 235   AddTab(browser(), url);
 236
 237   GURL hidden_url("http://foo.com");
 238   AddTab(other_user.get(), hidden_url);
 239
 240   // Create fake process numbers.
 241   GetProcess(browser())->SetProcessHandle(MakeProcessHandle(1).Pass());
 242   GetProcess(other_user.get())->SetProcessHandle(MakeProcessHandle(2).Pass());
 243
 244   EXPECT_DOUBLE_EQ(0, collector->UpdatePowerConsumptionForTesting());
 245   EXPECT_EQ(2u, collector->metrics_map_for_testing()->size());
 246
 247   collector->set_cpu_usage_callback_for_testing(
 248       base::Bind(&BrowserProcessPowerTest::ReturnCpuAsConstant,
 249                  base::Unretained(this),
 250                  5));
 251   EXPECT_DOUBLE_EQ(10, collector->UpdatePowerConsumptionForTesting());
 252
 253   // profile() should have an entry for |url| but not |hidden_url|.
 254   OriginPowerMap* origin_power_map_first =
 255       OriginPowerMapFactory::GetForBrowserContext(profile());
 256   EXPECT_EQ(100, origin_power_map_first->GetPowerForOrigin(url));
 257   EXPECT_EQ(0, origin_power_map_first->GetPowerForOrigin(hidden_url));
 258
 259   // |other_profile| should have an entry for |hidden_url| but not |url|.
 260   OriginPowerMap* origin_power_map_second =
 261       OriginPowerMapFactory::GetForBrowserContext(other_profile.get());
 262   EXPECT_EQ(0, origin_power_map_second->GetPowerForOrigin(url));
 263   EXPECT_EQ(100, origin_power_map_second->GetPowerForOrigin(hidden_url));
 264
 265   // Clean up
 266   chrome::CloseTab(other_user.get());
 267 }
 268
 269 TEST_F(BrowserProcessPowerTest, AppsRecordPowerUsage) {
 270 // Install an app (an extension*).
 271 #if defined(OS_WIN)
 272   base::FilePath extension_path(FILE_PATH_LITERAL("c:\\foo"));
 273 #elif defined(OS_POSIX)
 274   base::FilePath extension_path(FILE_PATH_LITERAL("/foo"));
 275 #endif
 276   base::DictionaryValue manifest;
 277   manifest.SetString("name", "Fake Name");
 278   manifest.SetString("version", "1");
 279   std::string error;
 280   char kTestAppId[] = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
 281   scoped_refptr<extensions::Extension> extension(
 282       extensions::Extension::Create(extension_path,
 283                                     extensions::Manifest::INTERNAL,
 284                                     manifest,
 285                                     extensions::Extension::NO_FLAGS,
 286                                     kTestAppId,
 287                                     &error));
 288   EXPECT_TRUE(extension.get()) << error;
 289   // Increment the apps count to avoid a DCHECK later.
 290   extensions::AppsClient::Get()->IncrementKeepAliveCount();
 291
 292   Profile* current_profile =
 293       profile_manager_->CreateTestingProfile("Test user");
 294   GURL url("chrome-extension://aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
 295   extensions::AppWindow* window = new extensions::AppWindow(
 296       current_profile, new ChromeAppDelegate(), extension.get());
 297   content::WebContents* web_contents(
 298       content::WebContents::Create(content::WebContents::CreateParams(
 299           current_profile,
 300           content::SiteInstance::CreateForURL(current_profile, url))));
 301   window->SetAppWindowContentsForTesting(
 302       scoped_ptr<extensions::AppWindowContents>(
 303           new TestAppWindowContents(web_contents)));
 304   extensions::AppWindowRegistry* app_registry =
 305       extensions::AppWindowRegistry::Get(current_profile);
 306   app_registry->AddAppWindow(window);
 307
 308   collector->set_cpu_usage_callback_for_testing(
 309       base::Bind(&BrowserProcessPowerTest::ReturnCpuAsConstant,
 310                  base::Unretained(this),
 311                  5));
 312   collector->UpdatePowerConsumptionForTesting();
 313   EXPECT_EQ(1u, collector->metrics_map_for_testing()->size());
 314
 315   // Clear the AppWindowContents before trying to close.
 316   window->SetAppWindowContentsForTesting(
 317       scoped_ptr<extensions::AppWindowContents>());
 318   window->OnNativeClose();
 319   collector->UpdatePowerConsumptionForTesting();
 320   EXPECT_EQ(0u, collector->metrics_map_for_testing()->size());
 321 }