Remember that we've white listed a certificate when we switch to a new tab....

chrome/browser/profile.cc

 // Copyright (c) 2006-2008 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/profile.h"
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "chrome/app/locales/locale_settings.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/extensions/user_script_master.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/profile_manager.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
 #include "chrome/browser/search_engines/template_url_model.h"
+#include "chrome/browser/ssl/ssl_host_state.h"
 #include "chrome/browser/visitedlink_master.h"
 #include "chrome/browser/webdata/web_data_service.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/resource_bundle.h"
@@ skipping 20 matching lines @@
 using base::Time;
 using base::TimeDelta;
 
 // Delay, in milliseconds, before we explicitly create the SessionService.
 static const int kCreateSessionServiceDelayMS = 500;
 
 // A pointer to the request context for the default profile.  See comments on
 // Profile::GetDefaultRequestContext.
 URLRequestContext* Profile::default_request_context_;
 
-//static
+// static
 void Profile::RegisterUserPrefs(PrefService* prefs) {
   prefs->RegisterBooleanPref(prefs::kSearchSuggestEnabled, true);
   prefs->RegisterBooleanPref(prefs::kSessionExitedCleanly, true);
   prefs->RegisterBooleanPref(prefs::kSafeBrowsingEnabled, true);
 #if defined(OS_MACOSX)
   // MASSIVE HACK!!! We don't have localization working yet. Undo this once we
   // do. TODO(port): take this out
   prefs->RegisterStringPref(prefs::kSpellCheckDictionary,
       L"IDS_SPELLCHECK_DICTIONARY");
 #elif defined(OS_WIN) || defined(OS_LINUX)
   prefs->RegisterLocalizedStringPref(prefs::kSpellCheckDictionary,
       IDS_SPELLCHECK_DICTIONARY);
 #endif
   prefs->RegisterBooleanPref(prefs::kEnableSpellCheck, true);
 }
 
-//static
+// static
 Profile* Profile::CreateProfile(const FilePath& path) {
   return new ProfileImpl(path);
 }
 
-//static
+// static
 URLRequestContext* Profile::GetDefaultRequestContext() {
   return default_request_context_;
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // OffTheRecordProfileImpl is a profile subclass that wraps an existing profile
 // to  make it suitable for the off the record mode.
 //
@@ skipping 50 matching lines @@
   }
 
   virtual ExtensionsService* GetExtensionsService() {
     return profile_->GetExtensionsService();
   }
 
   virtual UserScriptMaster* GetUserScriptMaster() {
     return profile_->GetUserScriptMaster();
   }
 
+  virtual SSLHostState* GetSSLHostState() {
+    if (!ssl_host_state_.get())
+      ssl_host_state_.reset(new SSLHostState());
+
+    DCHECK(ssl_host_state_->CalledOnValidThread());
+    return ssl_host_state_.get();
+  }
+
   virtual HistoryService* GetHistoryService(ServiceAccessType sat) {
     if (sat == EXPLICIT_ACCESS) {
       return profile_->GetHistoryService(sat);
     } else {
       NOTREACHED() << "This profile is OffTheRecord";
       return NULL;
     }
   }
 
   virtual WebDataService* GetWebDataService(ServiceAccessType sat) {
@@ skipping 134 matching lines @@
  private:
   // The real underlying profile.
   Profile* profile_;
 
   // The context to use for requests made from this OTR session.
   ChromeURLRequestContext* request_context_;
 
   // The download manager that only stores downloaded items in memory.
   scoped_refptr<DownloadManager> download_manager_;
 
+  // We don't want SSLHostState from the OTR profile to leak back to the main
+  // profile because then the main profile would learn some of the host names

[wtc, 2009/02/12 21:41:46]

I like this comment!

+  // the user visited while OTR.
+  scoped_ptr<SSLHostState> ssl_host_state_;
+
   // Time we were started.
   Time start_time_;
 
   DISALLOW_EVIL_CONSTRUCTORS(OffTheRecordProfileImpl);
 };
 
 ProfileImpl::ProfileImpl(const FilePath& path)
     : path_(path),
       off_the_record_(false),
 #ifdef CHROME_PERSONALIZATION
@@ skipping 17 matching lines @@
   prefs->AddPrefObserver(prefs::kEnableSpellCheck, this);
 }
 
 void ProfileImpl::InitExtensions() {
   if (user_script_master_ || extensions_service_)
     return;  // Already initialized.
 
   const CommandLine* command_line = CommandLine::ForCurrentProcess();
   bool user_scripts_enabled =
       command_line->HasSwitch(switches::kEnableUserScripts);
-  bool extensions_enabled = 
+  bool extensions_enabled =
       command_line->HasSwitch(switches::kEnableExtensions);
 
   FilePath script_dir;
   if (user_scripts_enabled) {
     script_dir = GetPath();
     script_dir = script_dir.Append(chrome::kUserScriptsDirname);
   }
 
   user_script_master_ = new UserScriptMaster(
       g_browser_process->file_thread()->message_loop(), script_dir);
@@ skipping 135 matching lines @@
 }
 
 ExtensionsService* ProfileImpl::GetExtensionsService() {
   return extensions_service_.get();
 }
 
 UserScriptMaster* ProfileImpl::GetUserScriptMaster() {
   return user_script_master_.get();
 }
 
+SSLHostState* ProfileImpl::GetSSLHostState() {
+  if (!ssl_host_state_.get())
+    ssl_host_state_.reset(new SSLHostState());
+
+  DCHECK(ssl_host_state_->CalledOnValidThread());
+  return ssl_host_state_.get();
+}
+
 PrefService* ProfileImpl::GetPrefs() {
   if (!prefs_.get()) {
     prefs_.reset(new PrefService(GetPrefFilePath().ToWStringHack()));
 
     // The Profile class and ProfileManager class may read some prefs so
     // register known prefs as soon as possible.
     Profile::RegisterUserPrefs(prefs_.get());
     ProfileManager::RegisterUserPrefs(prefs_.get());
 
     // The last session exited cleanly if there is no pref for
@@ skipping 165 matching lines @@
 TabRestoreService* ProfileImpl::GetTabRestoreService() {
   if (!tab_restore_service_.get())
     tab_restore_service_ = new TabRestoreService(this);
   return tab_restore_service_.get();
 }
 
 void ProfileImpl::ResetTabRestoreService() {
   tab_restore_service_ = NULL;
 }
 
-// To be run in the IO thread to notify all resource message filters that the 
+// To be run in the IO thread to notify all resource message filters that the
 // spellchecker has changed.
 class NotifySpellcheckerChangeTask : public Task {
  public:
   NotifySpellcheckerChangeTask(
       Profile* profile,
       const SpellcheckerReinitializedDetails& spellchecker)
       : profile_(profile),
         spellchecker_(spellchecker) {
   }
 
@@ skipping 23 matching lines @@
       last_spellchecker->Release();
   }
 
   // Retrieve the (perhaps updated recently) dictionary name from preferences.
   PrefService* prefs = GetPrefs();
   bool enable_spellcheck = prefs->GetBoolean(prefs::kEnableSpellCheck);
 
   if (enable_spellcheck) {
     std::wstring dict_dir;
     PathService::Get(chrome::DIR_APP_DICTIONARIES, &dict_dir);
-    // Note that, as the object pointed to by previously by spellchecker_ 
+    // Note that, as the object pointed to by previously by spellchecker_
     // is being deleted in the io thread, the spellchecker_ can be made to point
     // to a new object (RE-initialized) in parallel in this UI thread.
     spellchecker_ = new SpellChecker(dict_dir,
         prefs->GetString(prefs::kSpellCheckDictionary), GetRequestContext(),
         std::wstring());
     spellchecker_->AddRef();  // Manual refcounting.
   } else {
     spellchecker_ = NULL;
   }
 
   if (need_to_broadcast && io_thread) {  // Notify resource message filters.
     SpellcheckerReinitializedDetails scoped_spellchecker;
     scoped_spellchecker.spellchecker = spellchecker_;
     if (io_thread) {
       io_thread->message_loop()->PostTask(
-          FROM_HERE, 
+          FROM_HERE,
           new NotifySpellcheckerChangeTask(this, scoped_spellchecker));
     }
   }
 }
 
 void ProfileImpl::ReinitializeSpellChecker() {
   InitializeSpellChecker(true);
 }
 
 SpellChecker* ProfileImpl::GetSpellChecker() {
   if (!spellchecker_) {
     // This is where spellchecker gets initialized. Note that this is being
     // initialized in the ui_thread. However, this is not a problem as long as
     // it is *used* in the io thread.
-    // TODO (sidchat) One day, change everything so that spellchecker gets
+    // TODO(sidchat): One day, change everything so that spellchecker gets
     // initialized in the IO thread itself.
     InitializeSpellChecker(false);
   }
 
   return spellchecker_;
 }
 
 void ProfileImpl::MarkAsCleanShutdown() {
   if (prefs_.get()) {
     // The session cleanly exited, set kSessionExitedCleanly appropriately.
@@ skipping 24 matching lines @@
 }
 
 #ifdef CHROME_PERSONALIZATION
 ProfilePersonalization* ProfileImpl::GetProfilePersonalization() {
   if (!personalization_.get())
     personalization_.reset(
         Personalization::CreateProfilePersonalization(this));
   return personalization_.get();
 }
 #endif