Persist the alternate protocol as a string not an int to allow the enum to be changed without affec…

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/values.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/chrome_notification_types.h"
@@ skipping 317 matching lines @@
     }
 
     do {
       int port = 0;
       if (!port_alternate_protocol_dict->GetIntegerWithoutPathExpansion(
           "port", &port) || (port > (1 << 16))) {
         DVLOG(1) << "Malformed Alternate-Protocol server: " << server_str;
         detected_corrupted_prefs = true;
         continue;
       }
-      int protocol = 0;
-      if (!port_alternate_protocol_dict->GetIntegerWithoutPathExpansion(
-          "protocol", &protocol) || (protocol < 0) ||
-          (protocol > net::NUM_ALTERNATE_PROTOCOLS)) {
+      std::string protocol_str;
+      if (!port_alternate_protocol_dict->GetStringWithoutPathExpansion(
+              "protocol_str", &protocol_str)) {
         DVLOG(1) << "Malformed Alternate-Protocol server: " << server_str;
         detected_corrupted_prefs = true;
         continue;
+      }
+      net::AlternateProtocol protocol =
+          net::AlternateProtocolFromString(protocol_str);
+      if (protocol > net::NUM_ALTERNATE_PROTOCOLS) {
+        DVLOG(1) << "Malformed Alternate-Protocol server: " << server_str;
+        detected_corrupted_prefs = true;
+        continue;
       }
 
       net::PortAlternateProtocolPair port_alternate_protocol;
       port_alternate_protocol.port = port;
-      port_alternate_protocol.protocol = static_cast<net::AlternateProtocol>(
-          protocol);
+      port_alternate_protocol.protocol = protocol;
 
       (*alternate_protocol_map)[server] = port_alternate_protocol;
     } while (false);
   }
 
   BrowserThread::PostTask(
       BrowserThread::IO,
       FROM_HERE,
       base::Bind(&HttpServerPropertiesManager::
                  UpdateCacheFromPrefsOnIO,
@@ skipping 221 matching lines @@
     }
 
     // Save alternate_protocol.
     if (server_pref.alternate_protocol) {
       base::DictionaryValue* port_alternate_protocol_dict =
           new base::DictionaryValue;
       const net::PortAlternateProtocolPair* port_alternate_protocol =
           server_pref.alternate_protocol;
       port_alternate_protocol_dict->SetInteger(
           "port", port_alternate_protocol->port);
-      port_alternate_protocol_dict->SetInteger(
-          "protocol", port_alternate_protocol->protocol);
+      const char* protocol_str =
+          net::AlternateProtocolToString(port_alternate_protocol->protocol);
+      port_alternate_protocol_dict->SetString("protocol_str", protocol_str);
       server_pref_dict->SetWithoutPathExpansion(
           "alternate_protocol", port_alternate_protocol_dict);
     }
 
     if (server_pref.pipeline_capability != net::PIPELINE_UNKNOWN) {
       server_pref_dict->SetInteger("pipeline_capability",
                                    server_pref.pipeline_capability);
     }
 
     http_server_properties_dict.SetWithoutPathExpansion(server.ToString(),
@@ skipping 17 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