signin: pull basic SigninManager functionality into new SigninManagerBase class.

chrome/browser/chrome_content_browser_client.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/chrome_content_browser_client.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
@@ skipping 47 matching lines @@
 #include "chrome/browser/printing/printing_message_filter.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_io_data.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/renderer_host/chrome_render_message_filter.h"
 #include "chrome/browser/renderer_host/pepper/chrome_browser_pepper_host_factory.h"
 #include "chrome/browser/search/instant_service.h"
 #include "chrome/browser/search/instant_service_factory.h"
 #include "chrome/browser/search/search.h"
 #include "chrome/browser/search_engines/search_provider_install_state_message_filter.h"
-#include "chrome/browser/signin/signin_manager.h"
-#include "chrome/browser/signin/signin_manager_factory.h"
 #include "chrome/browser/speech/chrome_speech_recognition_manager_delegate.h"
 #include "chrome/browser/spellchecker/spellcheck_message_filter.h"
 #include "chrome/browser/ssl/ssl_add_certificate.h"
 #include "chrome/browser/ssl/ssl_blocking_page.h"
 #include "chrome/browser/ssl/ssl_tab_helper.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/toolkit_extra_parts.h"
 #include "chrome/browser/ui/chrome_select_file_policy.h"
 #include "chrome/browser/ui/tab_contents/chrome_web_contents_view_delegate.h"
 #include "chrome/browser/ui/webui/chrome_web_ui_controller_factory.h"
@@ skipping 80 matching lines @@
 #endif
 
 #if defined(OS_ANDROID)
 #include "ui/base/ui_base_paths.h"
 #endif
 
 #if defined(USE_NSS)
 #include "chrome/browser/ui/crypto_module_password_dialog.h"
 #endif
 
+#if !defined(OS_CHROMEOS)
+#include "chrome/browser/signin/signin_manager.h"
+#include "chrome/browser/signin/signin_manager_factory.h"
+#endif
+
 using base::FileDescriptor;
 using content::AccessTokenStore;
 using content::BrowserChildProcessHostIterator;
 using content::BrowserThread;
 using content::BrowserURLHandler;
 using content::ChildProcessSecurityPolicy;
 using content::FileDescriptorInfo;
 using content::QuotaPermissionContext;
 using content::RenderViewHost;
 using content::SiteInstance;
@@ skipping 270 matching lines @@
 
   // Replace the scheme with "chrome-search:".
   url_canon::Replacements<char> replacements;
   std::string search_scheme(chrome::kChromeSearchScheme);
   replacements.SetScheme(search_scheme.data(),
                          url_parse::Component(0, search_scheme.length()));
   effective_url = effective_url.ReplaceComponents(replacements);
   return effective_url;
 }
 
+#if !defined(OS_CHROMEOS)
 GURL GetEffectiveURLForSignin(const GURL& url) {
   CHECK(SigninManager::IsWebBasedSigninFlowURL(url));
 
   GURL effective_url(SigninManager::kChromeSigninEffectiveSite);
   // Copy the path because the argument to SetPathStr must outlive
   // the Replacements object.
   const std::string path_copy(url.path());
   GURL::Replacements replacements;
   replacements.SetPathStr(path_copy);
   effective_url = effective_url.ReplaceComponents(replacements);
   return effective_url;
 }
+#endif
 
 void SetApplicationLocaleOnIOThread(const std::string& locale) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   g_io_thread_application_locale.Get() = locale;
 }
 
 }  // namespace
 
 namespace chrome {
 
@@ skipping 253 matching lines @@
     content::BrowserContext* browser_context, const GURL& url) {
   Profile* profile = Profile::FromBrowserContext(browser_context);
   if (!profile)
     return url;
 
   // If the input |url| should be assigned to the Instant renderer, make its
   // effective URL distinct from other URLs on the search provider's domain.
   if (chrome::ShouldAssignURLToInstantRenderer(url, profile))
     return GetEffectiveURLForInstant(url, profile);
 
+#if !defined(OS_CHROMEOS)
   // If the input |url| should be assigned to the Signin renderer, make its
   // effective URL distinct from other URLs on the signin service's domain.
   // Note that the signin renderer will be allowed to sign the user in to
   // Chrome.
   if (SigninManager::IsWebBasedSigninFlowURL(url))
     return GetEffectiveURLForSignin(url);
+#endif
 
   // If the input |url| is part of an installed app, the effective URL is an
   // extension URL with the ID of that extension as the host. This has the
   // effect of grouping apps together in a common SiteInstance.
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   if (!extension_service)
     return url;
 
   const Extension* extension = extension_service->extensions()->
@@ skipping 18 matching lines @@
   // URLs for hosted apps (apart from bookmark apps) should have an extension
   // scheme by now.
 
   Profile* profile = Profile::FromBrowserContext(browser_context);
   if (!profile)
     return false;
 
   if (chrome::ShouldAssignURLToInstantRenderer(effective_url, profile))
     return true;
 
+#if !defined(OS_CHROMEOS)
   if (SigninManager::IsWebBasedSigninFlowURL(effective_url))
     return true;
+#endif
 
   if (!effective_url.SchemeIs(extensions::kExtensionScheme))
     return false;
 
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   if (!extension_service)
     return false;
 
   const Extension* extension = extension_service->extensions()->
@@ skipping 65 matching lines @@
       InstantServiceFactory::GetForProfile(profile);
   if (instant_service) {
     bool is_instant_process = instant_service->IsInstantProcess(
         process_host->GetID());
     bool should_be_in_instant_process =
         chrome::ShouldAssignURLToInstantRenderer(site_url, profile);
     if (is_instant_process || should_be_in_instant_process)
       return is_instant_process && should_be_in_instant_process;
   }
 
+#if !defined(OS_CHROMEOS)
   SigninManager* signin_manager = SigninManagerFactory::GetForProfile(profile);
   if (signin_manager && signin_manager->IsSigninProcess(process_host->GetID()))
     return SigninManager::IsWebBasedSigninFlowURL(site_url);
+#endif
 
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   extensions::ProcessMap* process_map = service->process_map();
 
   // Don't allow the Task Manager to share a process with anything else.
   // Otherwise it can affect the renderers it is observing.
   // Note: we could create another RenderProcessHostPrivilege bucket for
   // this to allow multiple chrome://tasks instances to share, but that's
   // a very unlikely case without serious consequences.
@@ skipping 77 matching lines @@
   // Remember the ID of the Instant process to signal the renderer process
   // on startup in |AppendExtraCommandLineSwitches| below.
   if (chrome::ShouldAssignURLToInstantRenderer(
           site_instance->GetSiteURL(), profile)) {
     InstantService* instant_service =
         InstantServiceFactory::GetForProfile(profile);
     if (instant_service)
       instant_service->AddInstantProcess(site_instance->GetProcess()->GetID());
   }
 
+#if !defined(OS_CHROMEOS)
   // We only expect there to be one signin process as we use process-per-site
   // for signin URLs. The signin process will be cleared from SigninManager
   // when the renderer is destroyed.
   if (SigninManager::IsWebBasedSigninFlowURL(site_instance->GetSiteURL())) {
     SigninManager* signin_manager =
         SigninManagerFactory::GetForProfile(profile);
     if (signin_manager)
       signin_manager->SetSigninProcess(site_instance->GetProcess()->GetID());
   }
+#endif
 
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   if (!service)
     return;
 
   const Extension* extension =
       service->extensions()->GetExtensionOrAppByURL(ExtensionURLInfo(
           site_instance->GetSiteURL()));
   if (!extension)
@@ skipping 174 matching lines @@
 
       if (!prefs->GetBoolean(prefs::kPrintPreviewDisabled))
         command_line->AppendSwitch(switches::kRendererPrintPreview);
 
       InstantService* instant_service =
           InstantServiceFactory::GetForProfile(profile);
       if (instant_service &&
           instant_service->IsInstantProcess(process->GetID()))
         command_line->AppendSwitch(switches::kInstantProcess);
 
+#if !defined(OS_CHROMEOS)
       SigninManager* signin_manager =
           SigninManagerFactory::GetForProfile(profile);
       if (signin_manager && signin_manager->IsSigninProcess(process->GetID()))
         command_line->AppendSwitch(switches::kSigninProcess);
+#endif
     }
 
     if (content::IsThreadedCompositingEnabled())
       command_line->AppendSwitch(switches::kEnableThreadedCompositing);
 
 #if defined(ENABLE_MESSAGE_CENTER)
     if (message_center::IsRichNotificationEnabled())
       command_line->AppendSwitch(switches::kDisableHTMLNotifications);
 #endif
 
@@ skipping 1003 matching lines @@
 #if defined(USE_NSS)
 crypto::CryptoModuleBlockingPasswordDelegate*
     ChromeContentBrowserClient::GetCryptoPasswordDelegate(
         const GURL& url) {
   return chrome::NewCryptoModuleBlockingDialogDelegate(
       chrome::kCryptoModulePasswordKeygen, url.host());
 }
 #endif
 
 }  // namespace chrome