Home | History | Annotate | Download | only in extensions 
      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/extensions/extension_gcm_app_handler.h"
      6 
      7 #include <vector>
      8 
      9 #include "base/bind.h"
     10 #include "base/bind_helpers.h"
     11 #include "base/command_line.h"
     12 #include "base/file_util.h"
     13 #include "base/files/file_path.h"
     14 #include "base/files/scoped_temp_dir.h"
     15 #include "base/location.h"
     16 #include "base/logging.h"
     17 #include "base/memory/ref_counted.h"
     18 #include "base/message_loop/message_loop.h"
     19 #include "base/path_service.h"
     20 #include "base/prefs/pref_service.h"
     21 #include "base/run_loop.h"
     22 #include "base/values.h"
     23 #include "chrome/browser/chrome_notification_types.h"
     24 #include "chrome/browser/extensions/extension_service.h"
     25 #include "chrome/browser/extensions/test_extension_service.h"
     26 #include "chrome/browser/extensions/test_extension_system.h"
     27 #include "chrome/browser/profiles/profile.h"
     28 #include "chrome/browser/services/gcm/fake_signin_manager.h"
     29 #include "chrome/browser/services/gcm/gcm_profile_service.h"
     30 #include "chrome/browser/services/gcm/gcm_profile_service_factory.h"
     31 #include "chrome/browser/signin/signin_manager_factory.h"
     32 #include "chrome/common/chrome_paths.h"
     33 #include "chrome/common/pref_names.h"
     34 #include "chrome/test/base/testing_profile.h"
     35 #include "components/gcm_driver/fake_gcm_app_handler.h"
     36 #include "components/gcm_driver/fake_gcm_client.h"
     37 #include "components/gcm_driver/fake_gcm_client_factory.h"
     38 #include "components/gcm_driver/gcm_client_factory.h"
     39 #include "components/gcm_driver/gcm_driver.h"
     40 #include "components/keyed_service/core/keyed_service.h"
     41 #include "content/public/browser/browser_context.h"
     42 #include "content/public/browser/browser_thread.h"
     43 #include "content/public/test/test_browser_thread_bundle.h"
     44 #include "content/public/test/test_utils.h"
     45 #include "extensions/browser/extension_system.h"
     46 #include "extensions/common/extension.h"
     47 #include "extensions/common/manifest.h"
     48 #include "extensions/common/manifest_constants.h"
     49 #include "extensions/common/permissions/api_permission.h"
     50 #include "extensions/common/permissions/permissions_data.h"
     51 #include "testing/gtest/include/gtest/gtest.h"
     52 
     53 #if !defined(OS_ANDROID)
     54 #include "chrome/browser/extensions/api/gcm/gcm_api.h"
     55 #endif
     56 
     57 #if defined(OS_CHROMEOS)
     58 #include "chrome/browser/chromeos/login/users/user_manager.h"
     59 #include "chrome/browser/chromeos/settings/cros_settings.h"
     60 #include "chrome/browser/chromeos/settings/device_settings_service.h"
     61 #endif
     62 
     63 namespace extensions {
     64 
     65 namespace {
     66 
     67 const char kTestExtensionName[] = "FooBar";
     68 const char kTestingUsername[] = "user1 (at) example.com";
     69 
     70 }  // namespace
     71 
     72 // Helper class for asynchronous waiting.
     73 class Waiter {
     74  public:
     75   Waiter() {}
     76   ~Waiter() {}
     77 
     78   // Waits until the asynchronous operation finishes.
     79   void WaitUntilCompleted() {
     80     run_loop_.reset(new base::RunLoop);
     81     run_loop_->Run();
     82   }
     83 
     84   // Signals that the asynchronous operation finishes.
     85   void SignalCompleted() {
     86     if (run_loop_ && run_loop_->running())
     87       run_loop_->Quit();
     88   }
     89 
     90   // Runs until UI loop becomes idle.
     91   void PumpUILoop() {
     92     base::MessageLoop::current()->RunUntilIdle();
     93   }
     94 
     95   // Runs until IO loop becomes idle.
     96   void PumpIOLoop() {
     97     content::BrowserThread::PostTask(
     98         content::BrowserThread::IO,
     99         FROM_HERE,
    100         base::Bind(&Waiter::OnIOLoopPump, base::Unretained(this)));
    101 
    102     WaitUntilCompleted();
    103   }
    104 
    105  private:
    106   void PumpIOLoopCompleted() {
    107     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
    108 
    109     SignalCompleted();
    110   }
    111 
    112   void OnIOLoopPump() {
    113     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
    114 
    115     content::BrowserThread::PostTask(
    116         content::BrowserThread::IO,
    117         FROM_HERE,
    118         base::Bind(&Waiter::OnIOLoopPumpCompleted, base::Unretained(this)));
    119   }
    120 
    121   void OnIOLoopPumpCompleted() {
    122     DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
    123 
    124     content::BrowserThread::PostTask(
    125         content::BrowserThread::UI,
    126         FROM_HERE,
    127         base::Bind(&Waiter::PumpIOLoopCompleted, base::Unretained(this)));
    128   }
    129 
    130   scoped_ptr<base::RunLoop> run_loop_;
    131 
    132   DISALLOW_COPY_AND_ASSIGN(Waiter);
    133 };
    134 
    135 class FakeExtensionGCMAppHandler : public ExtensionGCMAppHandler {
    136  public:
    137   FakeExtensionGCMAppHandler(Profile* profile, Waiter* waiter)
    138       : ExtensionGCMAppHandler(profile),
    139         waiter_(waiter),
    140         unregistration_result_(gcm::GCMClient::UNKNOWN_ERROR),
    141         app_handler_count_drop_to_zero_(false) {
    142   }
    143 
    144   virtual ~FakeExtensionGCMAppHandler() {
    145   }
    146 
    147   virtual void OnMessage(
    148       const std::string& app_id,
    149       const gcm::GCMClient::IncomingMessage& message) OVERRIDE {
    150   }
    151 
    152   virtual void OnMessagesDeleted(const std::string& app_id) OVERRIDE {
    153   }
    154 
    155   virtual void OnSendError(
    156       const std::string& app_id,
    157       const gcm::GCMClient::SendErrorDetails& send_error_details) OVERRIDE {
    158   }
    159 
    160   virtual void OnUnregisterCompleted(const std::string& app_id,
    161                                      gcm::GCMClient::Result result) OVERRIDE {
    162     unregistration_result_ = result;
    163     waiter_->SignalCompleted();
    164   }
    165 
    166   virtual void RemoveAppHandler(const std::string& app_id) OVERRIDE{
    167     ExtensionGCMAppHandler::RemoveAppHandler(app_id);
    168     if (!GetGCMDriver()->app_handlers().size())
    169       app_handler_count_drop_to_zero_ = true;
    170   }
    171 
    172   gcm::GCMClient::Result unregistration_result() const {
    173     return unregistration_result_;
    174   }
    175   bool app_handler_count_drop_to_zero() const {
    176     return app_handler_count_drop_to_zero_;
    177   }
    178 
    179  private:
    180   Waiter* waiter_;
    181   gcm::GCMClient::Result unregistration_result_;
    182   bool app_handler_count_drop_to_zero_;
    183 
    184   DISALLOW_COPY_AND_ASSIGN(FakeExtensionGCMAppHandler);
    185 };
    186 
    187 class ExtensionGCMAppHandlerTest : public testing::Test {
    188  public:
    189   static KeyedService* BuildGCMProfileService(
    190       content::BrowserContext* context) {
    191     return new gcm::GCMProfileService(
    192         Profile::FromBrowserContext(context),
    193         scoped_ptr<gcm::GCMClientFactory>(new gcm::FakeGCMClientFactory(
    194             gcm::FakeGCMClient::NO_DELAY_START,
    195             content::BrowserThread::GetMessageLoopProxyForThread(
    196                 content::BrowserThread::UI),
    197             content::BrowserThread::GetMessageLoopProxyForThread(
    198                 content::BrowserThread::IO))));
    199   }
    200 
    201   ExtensionGCMAppHandlerTest()
    202       : extension_service_(NULL),
    203         registration_result_(gcm::GCMClient::UNKNOWN_ERROR),
    204         unregistration_result_(gcm::GCMClient::UNKNOWN_ERROR) {
    205   }
    206 
    207   virtual ~ExtensionGCMAppHandlerTest() {
    208   }
    209 
    210   // Overridden from test::Test:
    211   virtual void SetUp() OVERRIDE {
    212     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
    213 
    214     // Make BrowserThread work in unittest.
    215     thread_bundle_.reset(new content::TestBrowserThreadBundle(
    216         content::TestBrowserThreadBundle::REAL_IO_THREAD));
    217 
    218     // Allow extension update to unpack crx in process.
    219     in_process_utility_thread_helper_.reset(
    220         new content::InProcessUtilityThreadHelper);
    221 
    222     // This is needed to create extension service under CrOS.
    223 #if defined(OS_CHROMEOS)
    224     test_user_manager_.reset(new chromeos::ScopedTestUserManager());
    225 #endif
    226 
    227     // Create a new profile.
    228     TestingProfile::Builder builder;
    229     builder.AddTestingFactory(SigninManagerFactory::GetInstance(),
    230                               gcm::FakeSigninManager::Build);
    231     profile_ = builder.Build();
    232     signin_manager_ = static_cast<gcm::FakeSigninManager*>(
    233         SigninManagerFactory::GetInstance()->GetForProfile(profile_.get()));
    234 
    235     // Create extension service in order to uninstall the extension.
    236     TestExtensionSystem* extension_system(
    237         static_cast<TestExtensionSystem*>(ExtensionSystem::Get(profile())));
    238     base::FilePath extensions_install_dir =
    239         temp_dir_.path().Append(FILE_PATH_LITERAL("Extensions"));
    240     extension_system->CreateExtensionService(
    241         CommandLine::ForCurrentProcess(), extensions_install_dir, false);
    242     extension_service_ = extension_system->Get(profile())->extension_service();
    243     extension_service_->set_extensions_enabled(true);
    244     extension_service_->set_show_extensions_prompts(false);
    245     extension_service_->set_install_updates_when_idle_for_test(false);
    246 
    247     // Enable GCM such that tests could be run on all channels.
    248     profile()->GetPrefs()->SetBoolean(prefs::kGCMChannelEnabled, true);
    249 
    250     // Create GCMProfileService that talks with fake GCMClient.
    251     gcm::GCMProfileServiceFactory::GetInstance()->SetTestingFactoryAndUse(
    252         profile(), &ExtensionGCMAppHandlerTest::BuildGCMProfileService);
    253 
    254     // Create a fake version of ExtensionGCMAppHandler.
    255     gcm_app_handler_.reset(new FakeExtensionGCMAppHandler(profile(), &waiter_));
    256   }
    257 
    258   virtual void TearDown() OVERRIDE {
    259 #if defined(OS_CHROMEOS)
    260     test_user_manager_.reset();
    261 #endif
    262 
    263     waiter_.PumpUILoop();
    264   }
    265 
    266   // Returns a barebones test extension.
    267   scoped_refptr<Extension> CreateExtension() {
    268     base::DictionaryValue manifest;
    269     manifest.SetString(manifest_keys::kVersion, "1.0.0.0");
    270     manifest.SetString(manifest_keys::kName, kTestExtensionName);
    271     base::ListValue* permission_list = new base::ListValue;
    272     permission_list->Append(base::Value::CreateStringValue("gcm"));
    273     manifest.Set(manifest_keys::kPermissions, permission_list);
    274 
    275     std::string error;
    276     scoped_refptr<Extension> extension = Extension::Create(
    277         temp_dir_.path(),
    278         Manifest::UNPACKED,
    279         manifest,
    280         Extension::NO_FLAGS,
    281         "ldnnhddmnhbkjipkidpdiheffobcpfmf",
    282         &error);
    283     EXPECT_TRUE(extension.get()) << error;
    284     EXPECT_TRUE(
    285         extension->permissions_data()->HasAPIPermission(APIPermission::kGcm));
    286 
    287     return extension;
    288   }
    289 
    290   void LoadExtension(const Extension* extension) {
    291     extension_service_->AddExtension(extension);
    292   }
    293 
    294   static bool IsCrxInstallerDone(extensions::CrxInstaller** installer,
    295                                  const content::NotificationSource& source,
    296                                  const content::NotificationDetails& details) {
    297     return content::Source<extensions::CrxInstaller>(source).ptr() ==
    298            *installer;
    299   }
    300 
    301   void UpdateExtension(const Extension* extension,
    302                        const std::string& update_crx) {
    303     base::FilePath data_dir;
    304     if (!PathService::Get(chrome::DIR_TEST_DATA, &data_dir)) {
    305       ADD_FAILURE();
    306       return;
    307     }
    308     data_dir = data_dir.AppendASCII("extensions");
    309     data_dir = data_dir.AppendASCII(update_crx);
    310 
    311     base::FilePath path = temp_dir_.path();
    312     path = path.Append(data_dir.BaseName());
    313     ASSERT_TRUE(base::CopyFile(data_dir, path));
    314 
    315     extensions::CrxInstaller* installer = NULL;
    316     content::WindowedNotificationObserver observer(
    317         chrome::NOTIFICATION_CRX_INSTALLER_DONE,
    318         base::Bind(&IsCrxInstallerDone, &installer));
    319     extension_service_->UpdateExtension(
    320         extension->id(), path, true, &installer);
    321 
    322     if (installer)
    323       observer.Wait();
    324   }
    325 
    326   void DisableExtension(const Extension* extension) {
    327     extension_service_->DisableExtension(
    328         extension->id(), Extension::DISABLE_USER_ACTION);
    329   }
    330 
    331   void EnableExtension(const Extension* extension) {
    332     extension_service_->EnableExtension(extension->id());
    333   }
    334 
    335   void UninstallExtension(const Extension* extension) {
    336     extension_service_->UninstallExtension(extension->id(), false, NULL);
    337   }
    338 
    339   void SignIn(const std::string& username) {
    340     signin_manager_->SignIn(username);
    341     waiter_.PumpIOLoop();
    342   }
    343 
    344   void SignOut() {
    345     signin_manager_->SignOut(signin_metrics::SIGNOUT_TEST);
    346     waiter_.PumpIOLoop();
    347   }
    348 
    349   void Register(const std::string& app_id,
    350                 const std::vector<std::string>& sender_ids) {
    351     GetGCMDriver()->Register(
    352         app_id,
    353         sender_ids,
    354         base::Bind(&ExtensionGCMAppHandlerTest::RegisterCompleted,
    355                    base::Unretained(this)));
    356   }
    357 
    358   void RegisterCompleted(const std::string& registration_id,
    359                          gcm::GCMClient::Result result) {
    360     registration_result_ = result;
    361     waiter_.SignalCompleted();
    362   }
    363 
    364   gcm::GCMDriver* GetGCMDriver() const {
    365     return gcm::GCMProfileServiceFactory::GetForProfile(profile())->driver();
    366   }
    367 
    368   bool HasAppHandlers(const std::string& app_id) const {
    369     return GetGCMDriver()->app_handlers().count(app_id);
    370   }
    371 
    372   Profile* profile() const { return profile_.get(); }
    373   Waiter* waiter() { return &waiter_; }
    374   FakeExtensionGCMAppHandler* gcm_app_handler() const {
    375     return gcm_app_handler_.get();
    376   }
    377   gcm::GCMClient::Result registration_result() const {
    378     return registration_result_;
    379   }
    380   gcm::GCMClient::Result unregistration_result() const {
    381     return unregistration_result_;
    382   }
    383 
    384  private:
    385   scoped_ptr<content::TestBrowserThreadBundle> thread_bundle_;
    386   scoped_ptr<content::InProcessUtilityThreadHelper>
    387       in_process_utility_thread_helper_;
    388   scoped_ptr<TestingProfile> profile_;
    389   ExtensionService* extension_service_;  // Not owned.
    390   gcm::FakeSigninManager* signin_manager_;  // Not owned.
    391   base::ScopedTempDir temp_dir_;
    392 
    393   // This is needed to create extension service under CrOS.
    394 #if defined(OS_CHROMEOS)
    395   chromeos::ScopedTestDeviceSettingsService test_device_settings_service_;
    396   chromeos::ScopedTestCrosSettings test_cros_settings_;
    397   scoped_ptr<chromeos::ScopedTestUserManager> test_user_manager_;
    398 #endif
    399 
    400   Waiter waiter_;
    401   scoped_ptr<FakeExtensionGCMAppHandler> gcm_app_handler_;
    402   gcm::GCMClient::Result registration_result_;
    403   gcm::GCMClient::Result unregistration_result_;
    404 
    405   DISALLOW_COPY_AND_ASSIGN(ExtensionGCMAppHandlerTest);
    406 };
    407 
    408 TEST_F(ExtensionGCMAppHandlerTest, AddAndRemoveAppHandler) {
    409   scoped_refptr<Extension> extension(CreateExtension());
    410 
    411   // App handler is added when extension is loaded.
    412   LoadExtension(extension);
    413   waiter()->PumpUILoop();
    414   EXPECT_TRUE(HasAppHandlers(extension->id()));
    415 
    416   // App handler is removed when extension is unloaded.
    417   DisableExtension(extension);
    418   waiter()->PumpUILoop();
    419   EXPECT_FALSE(HasAppHandlers(extension->id()));
    420 
    421   // App handler is added when extension is reloaded.
    422   EnableExtension(extension);
    423   waiter()->PumpUILoop();
    424   EXPECT_TRUE(HasAppHandlers(extension->id()));
    425 
    426   // App handler is removed when extension is uninstalled.
    427   UninstallExtension(extension);
    428   waiter()->PumpUILoop();
    429   EXPECT_FALSE(HasAppHandlers(extension->id()));
    430 }
    431 
    432 TEST_F(ExtensionGCMAppHandlerTest, UnregisterOnExtensionUninstall) {
    433   scoped_refptr<Extension> extension(CreateExtension());
    434   LoadExtension(extension);
    435 
    436   // Sign-in is needed for registration.
    437   SignIn(kTestingUsername);
    438 
    439   // Kick off registration.
    440   std::vector<std::string> sender_ids;
    441   sender_ids.push_back("sender1");
    442   Register(extension->id(), sender_ids);
    443   waiter()->WaitUntilCompleted();
    444   EXPECT_EQ(gcm::GCMClient::SUCCESS, registration_result());
    445 
    446   // Add another app handler in order to prevent the GCM service from being
    447   // stopped when the extension is uninstalled. This is needed because otherwise
    448   // we are not able to receive the unregistration result.
    449   GetGCMDriver()->AddAppHandler("Foo", gcm_app_handler());
    450 
    451   // Unregistration should be triggered when the extension is uninstalled.
    452   UninstallExtension(extension);
    453   waiter()->WaitUntilCompleted();
    454   EXPECT_EQ(gcm::GCMClient::SUCCESS,
    455             gcm_app_handler()->unregistration_result());
    456 
    457   // Clean up.
    458   GetGCMDriver()->RemoveAppHandler("Foo");
    459 }
    460 
    461 TEST_F(ExtensionGCMAppHandlerTest, UpdateExtensionWithGcmPermissionKept) {
    462   scoped_refptr<Extension> extension(CreateExtension());
    463 
    464   // App handler is added when the extension is loaded.
    465   LoadExtension(extension);
    466   waiter()->PumpUILoop();
    467   EXPECT_TRUE(HasAppHandlers(extension->id()));
    468 
    469   // App handler count should not drop to zero when the extension is updated.
    470   UpdateExtension(extension, "gcm2.crx");
    471   waiter()->PumpUILoop();
    472   EXPECT_FALSE(gcm_app_handler()->app_handler_count_drop_to_zero());
    473   EXPECT_TRUE(HasAppHandlers(extension->id()));
    474 }
    475 
    476 TEST_F(ExtensionGCMAppHandlerTest, UpdateExtensionWithGcmPermissionRemoved) {
    477   scoped_refptr<Extension> extension(CreateExtension());
    478 
    479   // App handler is added when the extension is loaded.
    480   LoadExtension(extension);
    481   waiter()->PumpUILoop();
    482   EXPECT_TRUE(HasAppHandlers(extension->id()));
    483 
    484   // App handler is removed when the extension is updated to the version that
    485   // has GCM permission removed.
    486   UpdateExtension(extension, "good2.crx");
    487   waiter()->PumpUILoop();
    488   EXPECT_TRUE(gcm_app_handler()->app_handler_count_drop_to_zero());
    489   EXPECT_FALSE(HasAppHandlers(extension->id()));
    490 }
    491 
    492 }  // namespace extensions
    493