Added completion notification to Profile's ClearNetworkingHistorySince.

chrome/browser/net/http_server_properties_manager.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/net/http_server_properties_manager.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
@@ skipping 73 matching lines @@
   ui_weak_ptr_factory_.reset();
   pref_change_registrar_.RemoveAll();
 }
 
 // static
 void HttpServerPropertiesManager::RegisterPrefs(PrefService* prefs) {
   prefs->RegisterDictionaryPref(prefs::kHttpServerProperties,
                                 PrefService::UNSYNCABLE_PREF);
 }
 
+// This is required for conformance with the HttpServerProperties interface.
 void HttpServerPropertiesManager::Clear() {
+  Clear(base::Closure());
+}
+
+void HttpServerPropertiesManager::Clear(const base::Closure& completion) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   http_server_properties_impl_->Clear();
-  ScheduleUpdatePrefsOnIO();
+  UpdatePrefsFromCacheOnIO(completion);
 }
 
 bool HttpServerPropertiesManager::SupportsSpdy(
     const net::HostPortPair& server) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return http_server_properties_impl_->SupportsSpdy(server);
 }
 
 void HttpServerPropertiesManager::SetSupportsSpdy(
     const net::HostPortPair& server,
@@ skipping 325 matching lines @@
 
 void HttpServerPropertiesManager::StartPrefsUpdateTimerOnIO(
     base::TimeDelta delay) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // This is overridden in tests to post the task without the delay.
   io_prefs_update_timer_->Start(
       FROM_HERE, delay, this,
       &HttpServerPropertiesManager::UpdatePrefsFromCacheOnIO);
 }
 
+// This is required so we can set this as the callback for a timer.
 void HttpServerPropertiesManager::UpdatePrefsFromCacheOnIO() {
+  UpdatePrefsFromCacheOnIO(base::Closure());
+}
+
+void HttpServerPropertiesManager::UpdatePrefsFromCacheOnIO(
+    const base::Closure& completion) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   base::ListValue* spdy_server_list = new base::ListValue;
   http_server_properties_impl_->GetSpdyServerList(spdy_server_list);
 
   net::SpdySettingsMap* spdy_settings_map = new net::SpdySettingsMap;
   *spdy_settings_map = http_server_properties_impl_->spdy_settings_map();
 
   net::AlternateProtocolMap* alternate_protocol_map =
       new net::AlternateProtocolMap;
   *alternate_protocol_map =
       http_server_properties_impl_->alternate_protocol_map();
 
   net::PipelineCapabilityMap* pipeline_capability_map =
       new net::PipelineCapabilityMap;
   *pipeline_capability_map =
       http_server_properties_impl_->GetPipelineCapabilityMap();
 
   // Update the preferences on the UI thread.
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&HttpServerPropertiesManager::UpdatePrefsOnUI,
                  ui_weak_ptr_,
                  base::Owned(spdy_server_list),
                  base::Owned(spdy_settings_map),
                  base::Owned(alternate_protocol_map),
-                 base::Owned(pipeline_capability_map)));
+                 base::Owned(pipeline_capability_map),
+                 completion));
 }
 
 // A local or temporary data structure to hold |supports_spdy|, SpdySettings,
 // PortAlternateProtocolPair, and |pipeline_capability| preferences for a
 // server. This is used only in UpdatePrefsOnUI.
 struct ServerPref {
   ServerPref()
       : supports_spdy(false),
         settings_map(NULL),
         alternate_protocol(NULL),
@@ skipping 10 matching lines @@
   bool supports_spdy;
   const net::SettingsMap* settings_map;
   const net::PortAlternateProtocolPair* alternate_protocol;
   net::HttpPipelinedHostCapability pipeline_capability;
 };
 
 void HttpServerPropertiesManager::UpdatePrefsOnUI(
     base::ListValue* spdy_server_list,
     net::SpdySettingsMap* spdy_settings_map,
     net::AlternateProtocolMap* alternate_protocol_map,
-    net::PipelineCapabilityMap* pipeline_capability_map) {
+    net::PipelineCapabilityMap* pipeline_capability_map,
+    const base::Closure& completion) {
 
   typedef std::map<net::HostPortPair, ServerPref> ServerPrefMap;
   ServerPrefMap server_pref_map;
 
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Add servers that support spdy to server_pref_map.
   std::string s;
   for (base::ListValue::const_iterator list_it = spdy_server_list->begin();
        list_it != spdy_server_list->end(); ++list_it) {
@@ skipping 113 matching lines @@
 
     servers_dict->SetWithoutPathExpansion(server.ToString(), server_pref_dict);
   }
 
   http_server_properties_dict.SetWithoutPathExpansion("servers", servers_dict);
   http_server_properties_dict.SetInteger("version", kVersionNumber);
   setting_prefs_ = true;
   pref_service_->Set(prefs::kHttpServerProperties,
                      http_server_properties_dict);
   setting_prefs_ = false;
+
+  // Note that |completion| will be fired after we have written everything to
+  // the Preferences, but likely before these changes are serialized to disk.
+  // This is not a problem though, as JSONPrefStore guarantees that this will
+  // happen soon, even if we shut down immediately.
+  if (!completion.is_null()) {
+    completion.Run();
+  }

[battre, 2012/10/23 08:38:33]

nit: no {}

[engedy, 2012/10/23 10:40:09]

Done.

 }
 
 void HttpServerPropertiesManager::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(type == chrome::NOTIFICATION_PREF_CHANGED);
   PrefService* prefs = content::Source<PrefService>(source).ptr();
   DCHECK(prefs == pref_service_);
   std::string* pref_name = content::Details<std::string>(details).ptr();
   if (*pref_name == prefs::kHttpServerProperties) {
     if (!setting_prefs_)
       ScheduleUpdateCacheOnUI();
   } else {
     NOTREACHED();
   }
 }
 
 }  // namespace chrome_browser_net