Quick-and-dirty hacks for getting policy working behind proxies.

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 <vector>
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
@@ skipping 771 matching lines @@
       if (UserManager::Get()->current_user_is_new())
         SetFirstLoginPrefs(user_profile->GetPrefs());
       // Make sure that the google service username is properly set (we do this
       // on every sign in, not just the first login, to deal with existing
       // profiles that might not have it set yet).
       StringPrefMember google_services_username;
       google_services_username.Init(prefs::kGoogleServicesUsername,
                                     user_profile->GetPrefs(), NULL);
       google_services_username.SetValue(
           UserManager::Get()->logged_in_user().display_email());
+      // Make sure we flip every profile to not share proxies if the user hasn't

[Nikita (slow), 2012/02/01 09:42:34]

Seems that if Chrome crashes inside user session, this setting would have
incorrect default value.

[pastarmovj, 2012/02/01 09:57:31]

Yes, theoretically if Chrome crashes right after this code and before the
preferences were written to disk it might lead to flipping back to the default
being now enabled, until the user logs out and back in. Then this code will get
re-executed and flip the bit again. However you are right that we might want to
have this code on the "crashed browser restore" code path too.

+      // specified so explicitly.
+      const PrefService::Preference* use_shared_proxies_pref =
+          user_profile->GetPrefs()->FindPreference(prefs::kUseSharedProxies);
+      if (use_shared_proxies_pref->IsDefaultValue())
+        user_profile->GetPrefs()->SetBoolean(prefs::kUseSharedProxies, false);
       RespectLocalePreference(user_profile);
       return;
     }
     case Profile::CREATE_STATUS_FAIL:
     default:
       NOTREACHED();
       return;
   }
 
   BootTimesLoader* btl = BootTimesLoader::Get();
@@ skipping 82 matching lines @@
   oauth_fetcher_->SetAutoFetchLimit(GaiaOAuthFetcher::OAUTH1_ALL_ACCESS_TOKEN);
   oauth_fetcher_->StartGetOAuthTokenRequest();
 }
 
 void LoginUtilsImpl::StartTokenServices(Profile* user_profile) {
   std::string oauth1_token;
   std::string oauth1_secret;
   if (!ReadOAuth1AccessToken(user_profile, &oauth1_token, &oauth1_secret))
     return;
 
-  FetchSecondaryTokens(user_profile->GetOffTheRecordProfile(), oauth1_token,
-                       oauth1_secret);
+  FetchSecondaryTokens(user_profile->GetOffTheRecordProfile(),
+                       oauth1_token, oauth1_secret);
 }
 
 void LoginUtilsImpl::StartSignedInServices(
     Profile* user_profile,
     const GaiaAuthConsumer::ClientLoginResult& credentials) {
   // Fetch/Create the SigninManager - this will cause the TokenService to load
   // tokens for the currently signed-in user if the SigninManager hasn't already
   // been initialized.
   SigninManager* signin = SigninManagerFactory::GetForProfile(user_profile);
   DCHECK(signin);
@@ skipping 367 matching lines @@
   oauth_login_verifier_->StartOAuthVerification();
 }
 
 
 void LoginUtilsImpl::FetchPolicyToken(Profile* offrecord_profile,
                                       const std::string& token,
                                       const std::string& secret) {
   // Fetch dm service token now, if it hasn't been fetched yet.
   if (!policy_oauth_fetcher_.get() || policy_oauth_fetcher_->failed()) {
     // Trigger oauth token fetch for user policy.
-    policy_oauth_fetcher_.reset(new PolicyOAuthFetcher(offrecord_profile,
-                                                       token,
-                                                       secret));
+    policy_oauth_fetcher_.reset(
+        new PolicyOAuthFetcher(authenticator_->authentication_profile(),
+                               token, secret));
     policy_oauth_fetcher_->Start();
   }
 
   // TODO(zelidrag): We should add initialization of other services somewhere
   // here as well. This could be handled with TokenService class once it is
   // ready to handle OAuth tokens.
 
   // We don't need authenticator instance any more, reset it so that
   // ScreenLocker would create a separate instance.
   // TODO(nkostylev): There's a potential race if SL would be created before
@@ skipping 83 matching lines @@
 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