Remove deprecated extension notification from device_local_account_browsertest.cc

chrome/browser/chromeos/policy/device_local_account_browsertest.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "ash/shell.h"
@@ skipping 103 matching lines @@
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_utils.h"
 #include "crypto/rsa_private_key.h"
 #include "extensions/browser/app_window/app_window.h"
 #include "extensions/browser/app_window/app_window_registry.h"
 #include "extensions/browser/app_window/native_app_window.h"
+#include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/install/crx_install_error.h"
 #include "extensions/browser/management_policy.h"
 #include "extensions/browser/notification_types.h"
+#include "extensions/browser/test_extension_registry_observer.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "net/base/url_util.h"
 #include "net/http/http_status_code.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_status.h"
@@ skipping 228 matching lines @@
   const base::DictionaryValue* pref =
       pref_change_registrar_.prefs()->GetDictionary(pref_.c_str());
   ASSERT_TRUE(pref);
   std::string actual_value;
   if (pref->GetStringWithoutPathExpansion(key_, &actual_value) &&
       actual_value == expected_value_) {
     run_loop_.Quit();
   }
 }
 
-bool DoesInstallSuccessReferToId(const std::string& id,
-                                 const content::NotificationSource& source,
-                                 const content::NotificationDetails& details) {
-  return content::Details<const extensions::InstalledExtensionInfo>(details)->
-      extension->id() == id;
-}
-
 bool DoesInstallFailureReferToId(const std::string& id,
                                  const content::NotificationSource& source,
                                  const content::NotificationDetails& details) {
   return content::Details<const extensions::CrxInstallError>(details)
              ->message()
              .find(base::UTF8ToUTF16(id)) != base::string16::npos;
 }
 
 scoped_ptr<net::FakeURLFetcher> RunCallbackAndReturnFakeURLFetcher(
     scoped_refptr<base::SequencedTaskRunner> task_runner,
@@ skipping 411 matching lines @@
   content::WebContents* contents_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DeviceLocalAccountTest);
 };
 
 static bool IsKnownUser(const AccountId& account_id) {
   return user_manager::UserManager::Get()->IsKnownUser(account_id);
 }
 
+// Helper that listen extension installation when new profile is created.
+class ExtensionInstallObserver : public content::NotificationObserver,
+                                 public extensions::ExtensionRegistryObserver {
+ public:
+  explicit ExtensionInstallObserver(const std::string& extension_id)
+      : registry_(nullptr),
+        waiting_extension_id_(extension_id),
+        observed_(false) {
+    registrar_.Add(this, chrome::NOTIFICATION_PROFILE_CREATED,
+                   content::NotificationService::AllSources());
+  }
+
+  ~ExtensionInstallObserver() override {
+    if (registry_ != nullptr)
+      registry_->RemoveObserver(this);
+  }
+
+  // Wait until an extension with |extension_id| is installed.
+  void Wait() {
+    if (!observed_)
+      run_loop_.Run();
+  }
+
+ private:
+  // extensions::ExtensionRegistryObserver:
+  void OnExtensionWillBeInstalled(content::BrowserContext* browser_context,
+                                  const extensions::Extension* extension,
+                                  bool is_update,
+                                  bool from_ephemeral,
+                                  const std::string& old_name) override {
+    if (waiting_extension_id_ == extension->id()) {
+      observed_ = true;
+      run_loop_.Quit();
+    }
+  }
+
+  // content::NotificationObserver:
+  void Observe(int type,
+               const content::NotificationSource& source,
+               const content::NotificationDetails& details) override {
+    DCHECK_EQ(chrome::NOTIFICATION_PROFILE_CREATED, type);
+
+    Profile* profile = content::Source<Profile>(source).ptr();
+    registry_ = extensions::ExtensionRegistry::Get(profile);
+
+    // Check if extension is already installed with newly created profile.
+    if (registry_->GetInstalledExtension(waiting_extension_id_)) {
+      observed_ = true;
+      run_loop_.Quit();
+      return;
+    }
+
+    // Start listening for extension installation.
+    registry_->AddObserver(this);
+  }
+
+  extensions::ExtensionRegistry* registry_;
+  base::RunLoop run_loop_;
+  content::NotificationRegistrar registrar_;
+  std::string waiting_extension_id_;
+  bool observed_;
+
+  DISALLOW_COPY_AND_ASSIGN(ExtensionInstallObserver);
+};
+
 IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, LoginScreen) {
   AddPublicSessionToDevicePolicy(kAccountId1);
   AddPublicSessionToDevicePolicy(kAccountId2);
 
   content::WindowedNotificationObserver(chrome::NOTIFICATION_USER_LIST_CHANGED,
                                         base::Bind(&IsKnownUser, account_id_1_))
       .Wait();
   EXPECT_TRUE(IsKnownUser(account_id_2_));
 
   CheckPublicSessionPresent(account_id_1_);
@@ skipping 215 matching lines @@
       "%s;%s",
       kGoodExtensionID,
       embedded_test_server()->GetURL(kRelativeUpdateURL).spec().c_str()));
 
   UploadAndInstallDeviceLocalAccountPolicy();
   AddPublicSessionToDevicePolicy(kAccountId1);
 
   WaitForPolicy();
 
   // Start listening for app/extension installation results.
-  content::WindowedNotificationObserver hosted_app_observer(
-      extensions::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED,
-      base::Bind(DoesInstallSuccessReferToId, kHostedAppID));
+  ExtensionInstallObserver install_observer(kHostedAppID);
   content::WindowedNotificationObserver extension_observer(
       extensions::NOTIFICATION_EXTENSION_INSTALL_ERROR,
       base::Bind(DoesInstallFailureReferToId, kGoodExtensionID));
-
   ASSERT_NO_FATAL_FAILURE(StartLogin(std::string(), std::string()));
 
   // Wait for the hosted app installation to succeed and the extension
   // installation to fail (because hosted apps are whitelisted for use in
   // device-local accounts and extensions are not).
-  hosted_app_observer.Wait();
+  install_observer.Wait();
   extension_observer.Wait();
 
   // Verify that the hosted app was installed.
   Profile* profile = GetProfileForTest();
   ASSERT_TRUE(profile);
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   EXPECT_TRUE(extension_service->GetExtensionById(kHostedAppID, true));
 
   // Verify that the extension was not installed.
@@ skipping 48 matching lines @@
       "%s;%s",
       kGoodExtensionID,
       embedded_test_server()->GetURL(kRelativeUpdateURL).spec().c_str()));
 
   UploadAndInstallDeviceLocalAccountPolicy();
   AddPublicSessionToDevicePolicy(kAccountId1);
 
   WaitForPolicy();
 
   // Start listening for app/extension installation results.
-  content::WindowedNotificationObserver hosted_app_observer(
-      extensions::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED,
-      base::Bind(DoesInstallSuccessReferToId, kHostedAppID));
+  ExtensionInstallObserver install_observer(kHostedAppID);
   content::WindowedNotificationObserver extension_observer(
       extensions::NOTIFICATION_EXTENSION_INSTALL_ERROR,
       base::Bind(DoesInstallFailureReferToId, kGoodExtensionID));
 
   ASSERT_NO_FATAL_FAILURE(StartLogin(std::string(), std::string()));
 
   // Wait for the hosted app installation to succeed and the extension
   // installation to fail.
-  hosted_app_observer.Wait();
+  install_observer.Wait();
   extension_observer.Wait();
 
   // Verify that the hosted app was installed.
   Profile* profile = GetProfileForTest();
   ASSERT_TRUE(profile);
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   EXPECT_TRUE(extension_service->GetExtensionById(kHostedAppID, true));
 
   // Verify that the extension was not installed.
@@ skipping 99 matching lines @@
       "%s;%s",
       kGoodExtensionID,
       embedded_test_server()->GetURL(kRelativeUpdateURL).spec().c_str()));
 
   UploadAndInstallDeviceLocalAccountPolicy();
   AddPublicSessionToDevicePolicy(kAccountId1);
 
   WaitForPolicy();
 
   // Start listening for app/extension installation results.
-  content::WindowedNotificationObserver hosted_app_observer(
-      extensions::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED,
-      base::Bind(DoesInstallSuccessReferToId, kHostedAppID));
+  ExtensionInstallObserver install_observer(kHostedAppID);
   content::WindowedNotificationObserver extension_observer(
       extensions::NOTIFICATION_EXTENSION_INSTALL_ERROR,
       base::Bind(DoesInstallFailureReferToId, kGoodExtensionID));
 
   ASSERT_NO_FATAL_FAILURE(StartLogin(std::string(), std::string()));
 
   // Wait for the hosted app installation to succeed and the extension
   // installation to fail (because hosted apps are whitelisted for use in
   // device-local accounts and extensions are not).
-  hosted_app_observer.Wait();
+  install_observer.Wait();
   extension_observer.Wait();
 
   // Verify that the extension was kept in the local cache.
   EXPECT_TRUE(cache_impl.GetExtension(kGoodExtensionID, hash, NULL, NULL));
 
   // Verify that the extension file was kept in the local cache.
   EXPECT_TRUE(PathExists(local_file));
 }
 
 IN_PROC_BROWSER_TEST_F(DeviceLocalAccountTest, ExternalData) {
@@ skipping 908 matching lines @@
       "  }"
       "}"));
 
   // Install and refresh the device policy now. This will also fetch the initial
   // user policy for the device-local account now.
   UploadAndInstallDeviceLocalAccountPolicy();
   AddPublicSessionToDevicePolicy(kAccountId1);
   WaitForPolicy();
 
   // Observe the app installation after login.
-  content::WindowedNotificationObserver extension_observer(
-      extensions::NOTIFICATION_EXTENSION_WILL_BE_INSTALLED_DEPRECATED,
-      base::Bind(DoesInstallSuccessReferToId, kShowManagedStorageID));
+  ExtensionInstallObserver install_observer(kShowManagedStorageID);
   ASSERT_NO_FATAL_FAILURE(StartLogin(std::string(), std::string()));
   WaitForSessionStart();
-  extension_observer.Wait();
+  install_observer.Wait();
 
   // Verify that the app was installed.
   Profile* profile = GetProfileForTest();
   ASSERT_TRUE(profile);
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   EXPECT_TRUE(extension_service->GetExtensionById(kShowManagedStorageID, true));
 
   // Wait for the app policy if it hasn't been fetched yet.
   ProfilePolicyConnector* connector =
@@ skipping 167 matching lines @@
   ASSERT_TRUE(content::ExecuteScript(contents_,
                                      "$('tos-accept-button').click();"));
 
   WaitForSessionStart();
 }
 
 INSTANTIATE_TEST_CASE_P(TermsOfServiceDownloadTestInstance,
                         TermsOfServiceDownloadTest, testing::Bool());
 
 }  // namespace policy