Removing last usage of default request context. Fixing up login_utils to not need it by allowing ac…

chrome/browser/chromeos/login/login_utils.cc

 // Copyright (c) 2012 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 "chrome/browser/chromeos/login/login_utils.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "ash/ash_switches.h"
@@ skipping 54 matching lines @@
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/net/gaia/gaia_auth_consumer.h"
 #include "chrome/common/net/gaia/gaia_urls.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/session_manager_client.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_service.h"
 #include "googleurl/src/gurl.h"
 #include "media/base/media_switches.h"
 #include "net/base/network_change_notifier.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/cookies/cookie_store.h"
 #include "net/http/http_auth_cache.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_transaction_factory.h"
 #include "net/url_request/url_request_context.h"
@@ skipping 134 matching lines @@
   std::string command_line_;
   PrefService* local_state_;
   base::OneShotTimer<JobRestartRequest> timer_;
 };
 
 class LoginUtilsImpl
     : public LoginUtils,
       public OAuth1TokenFetcher::Delegate,
       public OAuthLoginVerifier::Delegate,
       public net::NetworkChangeNotifier::ConnectionTypeObserver,
+      public content::NotificationObserver,
       public base::SupportsWeakPtr<LoginUtilsImpl> {
  public:
   LoginUtilsImpl()
       : pending_requests_(false),
         using_oauth_(false),
         has_cookies_(false),
         delegate_(NULL),
         job_restart_request_(NULL),
-        should_restore_auth_session_(false) {
+        should_restore_auth_session_(false),
+        url_request_context_getter_(NULL) {
     net::NetworkChangeNotifier::AddConnectionTypeObserver(this);
+    // During tests, the browser_process may not be initialized yet causing
+    // this to fail.
+    if (g_browser_process) {

[Nikita (slow), 2012/07/13 12:08:12]

What were those tests when this failed?

+      registrar_.Add(
+          this,
+          chrome::NOTIFICATION_PROFILE_URL_REQUEST_CONTEXT_GETTER_INITIALIZED,
+          content::Source<Profile>(ProfileManager::GetDefaultProfile()));
+    }
   }
 
   virtual ~LoginUtilsImpl() {
     net::NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
   }
 
   // LoginUtils implementation:
   virtual void DoBrowserLaunch(Profile* profile,
                                LoginDisplayHost* login_host) OVERRIDE;
   virtual void PrepareProfile(
@@ skipping 30 matching lines @@
   virtual void OnOAuthVerificationSucceeded(const std::string& user_name,
                                             const std::string& sid,
                                             const std::string& lsid,
                                             const std::string& auth) OVERRIDE;
   virtual void OnOAuthVerificationFailed(const std::string& user_name) OVERRIDE;
 
   // net::NetworkChangeNotifier::ConnectionTypeObserver overrides.
   virtual void OnConnectionTypeChanged(
       net::NetworkChangeNotifier::ConnectionType type) OVERRIDE;
 
+  // content::NotificationObserver overrides.
+  virtual void Observe(int type,
+                       const content::NotificationSource& source,
+                       const content::NotificationDetails& details) OVERRIDE;
+
  protected:
   virtual std::string GetOffTheRecordCommandLine(
       const GURL& start_url,
       const CommandLine& base_command_line,
       CommandLine *command_line);
 
  private:
   // Restarts OAuth session authentication check.
   void KickStartAuthentication(Profile* profile);
 
@@ skipping 48 matching lines @@
   // Delegate to be fired when the profile will be prepared.
   LoginUtils::Delegate* delegate_;
 
   // Used to restart Chrome to switch to the guest mode.
   JobRestartRequest* job_restart_request_;
 
   // True if should restore authentication session when notified about
   // online state change.
   bool should_restore_auth_session_;
 
+  content::NotificationRegistrar registrar_;
+
+  // This is set via a notification after the profile has initialized the
+  // getter.
+  net::URLRequestContextGetter* url_request_context_getter_;
+
   DISALLOW_COPY_AND_ASSIGN(LoginUtilsImpl);
 };
 
 class LoginUtilsWrapper {
  public:
   static LoginUtilsWrapper* GetInstance() {
     return Singleton<LoginUtilsWrapper>::get();
   }
 
   LoginUtils* get() {
@@ skipping 488 matching lines @@
     authenticator_ = NULL;
 
   if (authenticator_ == NULL)
     authenticator_ = new ParallelAuthenticator(consumer);
   return authenticator_;
 }
 
 // We use a special class for this so that it can be safely leaked if we
 // never connect. At shutdown the order is not well defined, and it's possible
 // for the infrastructure needed to unregister might be unstable and crash.
-class WarmingObserver : public NetworkLibrary::NetworkManagerObserver {
+class WarmingObserver : public NetworkLibrary::NetworkManagerObserver,
+                        public content::NotificationObserver {
  public:
-  WarmingObserver() {
+  WarmingObserver()
+      : url_request_context_getter_(NULL) {
     NetworkLibrary *netlib = CrosLibrary::Get()->GetNetworkLibrary();
     netlib->AddNetworkManagerObserver(this);
+    // During tests, the browser_process may not be initialized yet causing
+    // this to fail.
+    if (g_browser_process) {
+      registrar_.Add(
+          this,
+          chrome::NOTIFICATION_PROFILE_URL_REQUEST_CONTEXT_GETTER_INITIALIZED,
+          content::Source<Profile>(ProfileManager::GetDefaultProfile()));
+    }
   }
 
   virtual ~WarmingObserver() {}
 
   // If we're now connected, prewarm the auth url.
   virtual void OnNetworkManagerChanged(NetworkLibrary* netlib) {
     if (netlib->Connected()) {
       const int kConnectionsNeeded = 1;
       chrome_browser_net::PreconnectOnUIThread(
           GURL(GaiaUrls::GetInstance()->client_login_url()),
           chrome_browser_net::UrlInfo::EARLY_LOAD_MOTIVATED,
           kConnectionsNeeded,
-          make_scoped_refptr(Profile::GetDefaultRequestContextDeprecated()));
+          url_request_context_getter_);
       netlib->RemoveNetworkManagerObserver(this);
       delete this;
     }
   }
+
+  // content::NotificationObserver overrides.
+  virtual void Observe(int type,
+                       const content::NotificationSource& source,
+                       const content::NotificationDetails& details) {
+  switch (type) {
+    case chrome::NOTIFICATION_PROFILE_URL_REQUEST_CONTEXT_GETTER_INITIALIZED: {
+      Profile* profile = content::Source<Profile>(source).ptr();
+      url_request_context_getter_ = profile->GetRequestContext();
+      registrar_.Remove(
+          this,
+          chrome::NOTIFICATION_PROFILE_URL_REQUEST_CONTEXT_GETTER_INITIALIZED,
+          content::Source<Profile>(profile));
+
+      break;
+    }
+    default:
+      NOTREACHED();
+  }
+}
+ private:
+  net::URLRequestContextGetter* url_request_context_getter_;
+  content::NotificationRegistrar registrar_;
 };
 
 void LoginUtilsImpl::PrewarmAuthentication() {
   NetworkLibrary *network = CrosLibrary::Get()->GetNetworkLibrary();
   if (network->Connected()) {
     const int kConnectionsNeeded = 1;
     chrome_browser_net::PreconnectOnUIThread(
         GURL(GaiaUrls::GetInstance()->client_login_url()),
         chrome_browser_net::UrlInfo::EARLY_LOAD_MOTIVATED,
         kConnectionsNeeded,
-        make_scoped_refptr(Profile::GetDefaultRequestContextDeprecated()));
+        url_request_context_getter_);
   } else {
     new WarmingObserver();
   }
 }
 
 void LoginUtilsImpl::RestoreAuthenticationSession(Profile* user_profile) {
   // We don't need to restore session for demo/guest users.
   if (!UserManager::Get()->IsUserLoggedIn() ||
       UserManager::Get()->IsLoggedInAsGuest() ||
       UserManager::Get()->IsLoggedInAsDemoUser()) {
@@ skipping 193 matching lines @@
       // we need to kick off OAuth token verification process again.
       oauth_login_verifier_->ContinueVerification();
     } else if (should_restore_auth_session_) {
       should_restore_auth_session_ = false;
       Profile* user_profile = ProfileManager::GetDefaultProfile();
       KickStartAuthentication(user_profile);
     }
   }
 }
 
+void LoginUtilsImpl::Observe(int type,
+                             const content::NotificationSource& source,
+                             const content::NotificationDetails& details) {
+  switch (type) {
+    case chrome::NOTIFICATION_PROFILE_URL_REQUEST_CONTEXT_GETTER_INITIALIZED: {
+      Profile* profile = content::Source<Profile>(source).ptr();
+      url_request_context_getter_ = profile->GetRequestContext();
+      registrar_.Remove(
+          this,
+          chrome::NOTIFICATION_PROFILE_URL_REQUEST_CONTEXT_GETTER_INITIALIZED,
+          content::Source<Profile>(profile));
+      break;
+    }
+    default:
+      NOTREACHED();
+  }
+}
+
 // static
 LoginUtils* LoginUtils::Get() {
   return LoginUtilsWrapper::GetInstance()->get();
 }
 
 // static
 void LoginUtils::Set(LoginUtils* mock) {
   LoginUtilsWrapper::GetInstance()->reset(mock);
 }
 
 // static
 bool LoginUtils::IsWhitelisted(const std::string& username) {
   CrosSettings* cros_settings = CrosSettings::Get();
   bool allow_new_user = false;
   cros_settings->GetBoolean(kAccountsPrefAllowNewUser, &allow_new_user);
   if (allow_new_user)
     return true;
   return cros_settings->FindEmailInList(kAccountsPrefUsers, username);
 }
 
 }  // namespace chromeos