Hide ContentClient getters from embedders so that they they don't reuse content's embedder API. The…

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>
 
 #include "base/bind.h"
 #include "base/command_line.h"
+#include "base/lazy_instance.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/app/breakpad_mac.h"
 #include "chrome/browser/browser_about_handler.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_remover.h"
 #include "chrome/browser/character_encoding.h"
@@ skipping 149 matching lines @@
 using content::RenderViewHost;
 using content::SiteInstance;
 using content::WebContents;
 using extensions::APIPermission;
 using extensions::Extension;
 using extensions::Manifest;
 using webkit_glue::WebPreferences;
 
 namespace {
 
+// Cached version of the locale so we can return the locale on the I/O
+// thread.
+base::LazyInstance<std::string> g_io_thread_application_locale;
+
 const char* kPredefinedAllowedSocketOrigins[] = {
   "okddffdblfhhnmhodogpojmfkjmhinfp",  // Test SSH Client
   "pnhechapfaindjhompbnflcldabbghjo",  // HTerm App (SSH Client)
   "bglhmjfplikpjnfoegeomebmfnkjomhe",  // see crbug.com/122126
   "gbchcmhmhahfdphkhkmpfmihenigjmpp",  // Chrome Remote Desktop
   "kgngmbheleoaphbjbaiobfdepmghbfah",  // Pre-release Chrome Remote Desktop
   "odkaodonbgfohohmklejpjiejmcipmib",  // Dogfood Chrome Remote Desktop
   "ojoimpklfciegopdfgeenehpalipignm",  // Chromoting canary
   "cbkkbcmdlboombapidmoeolnmdacpkch",  // see crbug.com/129089
   "hhnbmknkdabfoieppbbljkhkfjcmcbjh",  // see crbug.com/134099
@@ skipping 261 matching lines @@
   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;
 }
 
+void SetApplicationLocaleOnIOThread(const std::string& locale) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  g_io_thread_application_locale.Get() = locale;
+}
+
 }  // namespace
 
 namespace chrome {
 
 ChromeContentBrowserClient::ChromeContentBrowserClient() {
   for (size_t i = 0; i < arraysize(kPredefinedAllowedSocketOrigins); ++i)
     allowed_socket_origins_.insert(kPredefinedAllowedSocketOrigins[i]);
 }
 
 ChromeContentBrowserClient::~ChromeContentBrowserClient() {
 }
 
 // static
 void ChromeContentBrowserClient::RegisterUserPrefs(
     PrefRegistrySyncable* registry) {
   registry->RegisterBooleanPref(prefs::kDisable3DAPIs,
                                 false,
                                 PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterBooleanPref(prefs::kEnableHyperlinkAuditing,
                                 true,
                                 PrefRegistrySyncable::UNSYNCABLE_PREF);
   registry->RegisterBooleanPref(prefs::kEnableMemoryInfo,
                                 false,
                                 PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
+// static
+void ChromeContentBrowserClient::SetApplicationLocale(
+    const std::string& locale) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  // This object is guaranteed to outlive all threads so we don't have to
+  // worry about the lack of refcounting and can just post as Unretained.
+  //
+  // The common case is that this function is called early in Chrome startup
+  // before any threads are created (it will also be called later if the user
+  // changes the pref). In this case, there will be no threads created and
+  // posting will fail. When there are no threads, we can just set the string
+  // without worrying about threadsafety.
+  if (!BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+          base::Bind(&SetApplicationLocaleOnIOThread, locale))) {
+    g_io_thread_application_locale.Get() = locale;
+  }
+}
+
 content::BrowserMainParts* ChromeContentBrowserClient::CreateBrowserMainParts(
     const content::MainFunctionParams& parameters) {
   ChromeBrowserMainParts* main_parts;
   // Construct the Main browser parts based on the OS type.
 #if defined(OS_WIN)
   main_parts = new ChromeBrowserMainPartsWin(parameters);
 #elif defined(OS_MACOSX)
   main_parts = new ChromeBrowserMainPartsMac(parameters);
 #elif defined(OS_CHROMEOS)
   main_parts = new chromeos::ChromeBrowserMainPartsChromeos(parameters);
@@ skipping 754 matching lines @@
 
   // The command line switch kEnableBenchmarking needs to be specified along
   // with the kEnableStatsTable switch to ensure that the stats table global
   // is initialized correctly.
   if (command_line->HasSwitch(switches::kEnableBenchmarking))
     DCHECK(command_line->HasSwitch(switches::kEnableStatsTable));
 }
 
 std::string ChromeContentBrowserClient::GetApplicationLocale() {
   if (BrowserThread::CurrentlyOn(BrowserThread::IO))
-    return io_thread_application_locale_;
+    return g_io_thread_application_locale.Get();
   return g_browser_process->GetApplicationLocale();
 }
 
 std::string ChromeContentBrowserClient::GetAcceptLangs(
     content::BrowserContext* context) {
   Profile* profile = Profile::FromBrowserContext(context);
   return profile->GetPrefs()->GetString(prefs::kAcceptLanguages);
 }
 
 gfx::ImageSkia* ChromeContentBrowserClient::GetDefaultFavicon() {
@@ skipping 617 matching lines @@
   content::BrowserContext* browser_context =
       rvh->GetProcess()->GetBrowserContext();
   DictionaryPrefUpdate update(
       Profile::FromBrowserContext(browser_context)->GetPrefs(),
       prefs::kWebKitInspectorSettings);
   DictionaryValue* inspector_settings = update.Get();
   inspector_settings->SetWithoutPathExpansion(key,
                                               Value::CreateStringValue(value));
 }
 
-void ChromeContentBrowserClient::ClearInspectorSettings(RenderViewHost* rvh) {
-  content::BrowserContext* browser_context =
-      rvh->GetProcess()->GetBrowserContext();
-  Profile::FromBrowserContext(browser_context)->GetPrefs()->
-      ClearPref(prefs::kWebKitInspectorSettings);
-}
-
 void ChromeContentBrowserClient::BrowserURLHandlerCreated(
     BrowserURLHandler* handler) {
   // Add the default URL handlers.
   handler->AddHandlerPair(&ExtensionWebUI::HandleChromeURLOverride,
                           BrowserURLHandler::null_handler());
   handler->AddHandlerPair(BrowserURLHandler::null_handler(),
                           &ExtensionWebUI::HandleChromeURLOverrideReverse);
 
   // about: handler. Must come before chrome: handler, since it will
   // rewrite about: urls to chrome: URLs and then expect chrome: to
@@ skipping 239 matching lines @@
 
 #if defined(USE_NSS)
 crypto::CryptoModuleBlockingPasswordDelegate*
     ChromeContentBrowserClient::GetCryptoPasswordDelegate(
         const GURL& url) {
   return chrome::NewCryptoModuleBlockingDialogDelegate(
       chrome::kCryptoModulePasswordKeygen, url.host());
 }
 #endif
 
-void ChromeContentBrowserClient::SetApplicationLocale(
-    const std::string& locale) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  // This object is guaranteed to outlive all threads so we don't have to
-  // worry about the lack of refcounting and can just post as Unretained.
-  //
-  // The common case is that this function is called early in Chrome startup
-  // before any threads are created (it will also be called later if the user
-  // changes the pref). In this case, there will be no threads created and
-  // posting will fail. When there are no threads, we can just set the string
-  // without worrying about threadsafety.
-  if (!BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-          base::Bind(
-              &ChromeContentBrowserClient::SetApplicationLocaleOnIOThread,
-              base::Unretained(this), locale)))
-    io_thread_application_locale_ = locale;
-}
-
-void ChromeContentBrowserClient::SetApplicationLocaleOnIOThread(
-    const std::string& locale) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  io_thread_application_locale_ = locale;
-}
-
 }  // namespace chrome