Ignore the following http server properties in prefs file

chrome/browser/net/http_server_properties_manager.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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/values.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
@@ skipping 218 matching lines @@
   // Parse the preferences into a SpdySettingsMap.
   net::SpdySettingsMap* spdy_settings_map = new net::SpdySettingsMap;
 
   // Parse the preferences into a AlternateProtocolMap.
   net::AlternateProtocolMap* alternate_protocol_map =
       new net::AlternateProtocolMap;
 
   net::PipelineCapabilityMap* pipeline_capability_map =
       new net::PipelineCapabilityMap;
 
+  bool detected_corrupted_prefs = false;
   const base::DictionaryValue& http_server_properties_dict =
       *pref_service_->GetDictionary(prefs::kHttpServerProperties);
   for (base::DictionaryValue::key_iterator it =
        http_server_properties_dict.begin_keys();
        it != http_server_properties_dict.end_keys(); ++it) {
     // Get server's host/pair.
     const std::string& server_str = *it;
     net::HostPortPair server = net::HostPortPair::FromString(server_str);
     if (server.host().empty()) {
       DVLOG(1) << "Malformed http_server_properties for server: " << server_str;
-      NOTREACHED();
+      detected_corrupted_prefs = true;
       continue;
     }
 
     base::DictionaryValue* server_pref_dict = NULL;
     if (!http_server_properties_dict.GetDictionaryWithoutPathExpansion(
         server_str, &server_pref_dict)) {
       DVLOG(1) << "Malformed http_server_properties server: " << server_str;
-      NOTREACHED();
+      detected_corrupted_prefs = true;
       continue;
     }
 
     // Get if server supports Spdy.
     bool supports_spdy = false;
     if ((server_pref_dict->GetBoolean(
          "supports_spdy", &supports_spdy)) && supports_spdy) {
       spdy_servers->push_back(server_str);
     }
 
     // Get SpdySettings.
     DCHECK(!ContainsKey(*spdy_settings_map, server));
     base::ListValue* spdy_settings_list = NULL;
     if (server_pref_dict->GetListWithoutPathExpansion(
         "settings", &spdy_settings_list)) {
       spdy::SpdySettings spdy_settings;
 
       for (base::ListValue::const_iterator list_it =
            spdy_settings_list->begin();
            list_it != spdy_settings_list->end(); ++list_it) {
         if ((*list_it)->GetType() != Value::TYPE_DICTIONARY) {
           DVLOG(1) << "Malformed SpdySettingsList for server: " << server_str;
-          NOTREACHED();
+          detected_corrupted_prefs = true;
           continue;
         }
 
         const base::DictionaryValue* spdy_setting_dict =
             static_cast<const base::DictionaryValue*>(*list_it);
 
         int id = 0;
         if (!spdy_setting_dict->GetIntegerWithoutPathExpansion("id", &id)) {
           DVLOG(1) << "Malformed id in SpdySettings for server: " << server_str;
-          NOTREACHED();
+          detected_corrupted_prefs = true;
           continue;
         }
 
         int value = 0;
         if (!spdy_setting_dict->GetIntegerWithoutPathExpansion("value",
                                                                &value)) {
           DVLOG(1) << "Malformed value in SpdySettings for server: " <<
               server_str;
-          NOTREACHED();
+          detected_corrupted_prefs = true;
           continue;
         }
 
         spdy::SettingsFlagsAndId flags_and_id(0);
         flags_and_id.set_id(id);
         flags_and_id.set_flags(spdy::SETTINGS_FLAG_PERSISTED);
 
         spdy_settings.push_back(spdy::SpdySetting(flags_and_id, value));
       }
 
@@ skipping 14 matching lines @@
     if (!server_pref_dict->GetDictionaryWithoutPathExpansion(
         "alternate_protocol", &port_alternate_protocol_dict)) {
       continue;
     }
 
     do {
       int port = 0;
       if (!port_alternate_protocol_dict->GetIntegerWithoutPathExpansion(
           "port", &port) || (port > (1 << 16))) {
         DVLOG(1) << "Malformed Alternate-Protocol server: " << server_str;
-        NOTREACHED();
+        detected_corrupted_prefs = true;
         continue;
       }
       int protocol = 0;
       if (!port_alternate_protocol_dict->GetIntegerWithoutPathExpansion(
           "protocol", &protocol) || (protocol < 0) ||
           (protocol > net::NUM_ALTERNATE_PROTOCOLS)) {
         DVLOG(1) << "Malformed Alternate-Protocol server: " << server_str;
-        NOTREACHED();
+        detected_corrupted_prefs = true;
         continue;
       }
 
       net::PortAlternateProtocolPair port_alternate_protocol;
       port_alternate_protocol.port = port;
       port_alternate_protocol.protocol = static_cast<net::AlternateProtocol>(
           protocol);
 
       (*alternate_protocol_map)[server] = port_alternate_protocol;
     } while (false);
   }
 
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&HttpServerPropertiesManager::
                  UpdateCacheFromPrefsOnIO,
                  base::Unretained(this),
                  base::Owned(spdy_servers),
                  base::Owned(spdy_settings_map),
                  base::Owned(alternate_protocol_map),
-                 base::Owned(pipeline_capability_map)));
+                 base::Owned(pipeline_capability_map),
+                 detected_corrupted_prefs));
 }
 
 void HttpServerPropertiesManager::UpdateCacheFromPrefsOnIO(
     StringVector* spdy_servers,
     net::SpdySettingsMap* spdy_settings_map,
     net::AlternateProtocolMap* alternate_protocol_map,
-    net::PipelineCapabilityMap* pipeline_capability_map) {
+    net::PipelineCapabilityMap* pipeline_capability_map,
+    bool detected_corrupted_prefs) {
   // Preferences have the master data because admins might have pushed new
   // preferences. Update the cached data with new data from preferences.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   http_server_properties_impl_->InitializeSpdyServers(spdy_servers, true);
 
   // Clear the cached data and use the new spdy_settings from preferences.
   http_server_properties_impl_->InitializeSpdySettingsServers(
       spdy_settings_map);
 
   // Clear the cached data and use the new Alternate-Protocol server list from
   // preferences.
   http_server_properties_impl_->InitializeAlternateProtocolServers(
       alternate_protocol_map);
 
   http_server_properties_impl_->InitializePipelineCapabilities(
       pipeline_capability_map);
+
+  // Update the prefs with what we have read (delete all corrupted prefs).
+  if (detected_corrupted_prefs)
+    ScheduleUpdatePrefsOnIO();
 }
 
 
 //
 // Update Preferences with data from the cached data.
 //
 void HttpServerPropertiesManager::ScheduleUpdatePrefsOnIO() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // Cancel pending updates, if any.
   io_prefs_update_timer_->Stop();
@@ skipping 215 matching lines @@
   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