Added an observer for 'pref::kDefaultCharset' change I forgot to add in rXXXX...

chrome/browser/net/chrome_url_request_context.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/net/chrome_url_request_context.h"
 
 #include "base/command_line.h"
 #include "base/string_util.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/privacy_blacklist/blacklist.h"
@@ skipping 253 matching lines @@
   return context;
 }
 
 ChromeURLRequestContext::ChromeURLRequestContext(Profile* profile)
     : prefs_(profile->GetPrefs()),
       is_media_(false),
       is_off_the_record_(profile->IsOffTheRecord()) {
   // Set up Accept-Language and Accept-Charset header values
   accept_language_ = net::HttpUtil::GenerateAcceptLanguageHeader(
       WideToASCII(prefs_->GetString(prefs::kAcceptLanguages)));
-  accept_charset_ = net::HttpUtil::GenerateAcceptCharsetHeader(
-      WideToASCII(prefs_->GetString(prefs::kDefaultCharset)));
+  std::string default_charset =
+      WideToASCII(prefs_->GetString(prefs::kDefaultCharset));
+  accept_charset_ =
+      net::HttpUtil::GenerateAcceptCharsetHeader(default_charset);
 
   // At this point, we don't know the charset of the referring page
   // where a url request originates from. This is used to get a suggested
   // filename from Content-Disposition header made of raw 8bit characters.
   // Down the road, it can be overriden if it becomes known (for instance,
   // when download request is made through the context menu in a web page).
   // At the moment, it'll remain 'undeterministic' when a user
   // types a URL in the omnibar or click on a download link in a page.
   // For the latter, we need a change on the webkit-side.
   // We initialize it to the default charset here and a user will
   // have an *arguably* better default charset for interpreting a raw 8bit
   // C-D header field.  It means the native OS codepage fallback in
   // net_util::GetSuggestedFilename is unlikely to be taken.
-  referrer_charset_ = accept_charset_;
+  referrer_charset_ = default_charset;

[wtc, 2009/07/16 01:14:47]

Question: so referrer_charset_ should contain a single
charset and should not have the 'q' value?

 
   cookie_policy_.SetType(net::CookiePolicy::FromInt(
       prefs_->GetInteger(prefs::kCookieBehavior)));
 
   blacklist_ = profile->GetBlacklist();
 
   force_tls_state_ = profile->GetForceTLSState();
 
   if (profile->GetExtensionsService()) {
     const ExtensionList* extensions =
         profile->GetExtensionsService()->extensions();
     for (ExtensionList::const_iterator iter = extensions->begin();
         iter != extensions->end(); ++iter) {
       extension_paths_[(*iter)->id()] = (*iter)->path();
     }
   }
 
   if (profile->GetUserScriptMaster())
     user_script_dir_path_ = profile->GetUserScriptMaster()->user_script_dir();
 
   prefs_->AddPrefObserver(prefs::kAcceptLanguages, this);
   prefs_->AddPrefObserver(prefs::kCookieBehavior, this);
+  prefs_->AddPrefObserver(prefs::kDefaultCharset, this);
 
   if (!is_off_the_record_) {
     registrar_.Add(this, NotificationType::EXTENSIONS_LOADED,
                    NotificationService::AllSources());
     registrar_.Add(this, NotificationType::EXTENSION_UNLOADED,
                    NotificationService::AllSources());
   }
 }
 
 // NotificationObserver implementation.
@@ skipping 11 matching lines @@
           NewRunnableMethod(this,
                             &ChromeURLRequestContext::OnAcceptLanguageChange,
                             accept_language));
     } else if (*pref_name_in == prefs::kCookieBehavior) {
       net::CookiePolicy::Type policy_type = net::CookiePolicy::FromInt(
           prefs_->GetInteger(prefs::kCookieBehavior));
       g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
           NewRunnableMethod(this,
                             &ChromeURLRequestContext::OnCookiePolicyChange,
                             policy_type));
+    } else if (*pref_name_in == prefs::kDefaultCharset) {
+      std::string default_charset =
+          WideToASCII(prefs->GetString(prefs::kDefaultCharset));
+      g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
+          NewRunnableMethod(this,
+                            &ChromeURLRequestContext::OnDefaultCharsetChange,
+                            default_charset));
     }
   } else if (NotificationType::EXTENSIONS_LOADED == type) {
     ExtensionPaths* new_paths = new ExtensionPaths;
     ExtensionList* extensions = Details<ExtensionList>(details).ptr();
     DCHECK(extensions);
     for (ExtensionList::const_iterator iter = extensions->begin();
          iter != extensions->end(); ++iter) {
       new_paths->insert(ExtensionPaths::value_type((*iter)->id(),
                                                    (*iter)->path()));
     }
     g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
         NewRunnableMethod(this, &ChromeURLRequestContext::OnNewExtensions,
                           new_paths));
   } else if (NotificationType::EXTENSION_UNLOADED == type) {
     Extension* extension = Details<Extension>(details).ptr();
     g_browser_process->io_thread()->message_loop()->PostTask(FROM_HERE,
         NewRunnableMethod(this, &ChromeURLRequestContext::OnUnloadedExtension,
                           extension->id()));
   } else {
     NOTREACHED();
   }
 }
 
 void ChromeURLRequestContext::CleanupOnUIThread() {
   // Unregister for pref notifications.
   prefs_->RemovePrefObserver(prefs::kAcceptLanguages, this);
   prefs_->RemovePrefObserver(prefs::kCookieBehavior, this);
+  prefs_->RemovePrefObserver(prefs::kDefaultCharset, this);
   prefs_ = NULL;
 
   registrar_.RemoveAll();
 }
 
 FilePath ChromeURLRequestContext::GetPathForExtension(const std::string& id) {
   ExtensionPaths::iterator iter = extension_paths_.find(id);
   if (iter != extension_paths_.end()) {
     return iter->second;
   } else {
@@ skipping 45 matching lines @@
       net::HttpUtil::GenerateAcceptLanguageHeader(accept_language);
 }
 
 void ChromeURLRequestContext::OnCookiePolicyChange(
     net::CookiePolicy::Type type) {
   DCHECK(MessageLoop::current() ==
          ChromeThread::GetMessageLoop(ChromeThread::IO));
   cookie_policy_.SetType(type);
 }
 
+void ChromeURLRequestContext::OnDefaultCharsetChange(
+    const std::string& default_charset) {
+  DCHECK(MessageLoop::current() ==
+         ChromeThread::GetMessageLoop(ChromeThread::IO));
+  referrer_charset_ = default_charset;
+  accept_charset_ =
+      net::HttpUtil::GenerateAcceptCharsetHeader(default_charset);
+}
+
 void ChromeURLRequestContext::OnNewExtensions(ExtensionPaths* new_paths) {
   extension_paths_.insert(new_paths->begin(), new_paths->end());
   delete new_paths;
 }
 
 void ChromeURLRequestContext::OnUnloadedExtension(
     const std::string& extension_id) {
   ExtensionPaths::iterator iter = extension_paths_.find(extension_id);
   DCHECK(iter != extension_paths_.end());
   extension_paths_.erase(iter);
@@ skipping 13 matching lines @@
   // Do not delete the cookie store in the case of the media context, as it is
   // owned by the original context.
   if (!is_media_)
     delete cookie_store_;
 
   // Do not delete the proxy service in the case of OTR or media contexts, as
   // it is owned by the original URLRequestContext.
   if (!is_off_the_record_ && !is_media_)
     delete proxy_service_;
 }