Refactor alternate protocol dictionary parsing.

net/http/http_server_properties_manager.cc

 // Copyright 2014 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 "net/http/http_server_properties_manager.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 432 matching lines @@
                << server.ToString();
       NOTREACHED();
       continue;
     }
     SettingsFlagsAndValue flags_and_value(SETTINGS_FLAG_PERSISTED, value);
     settings_map[static_cast<SpdySettingsIds>(id)] = flags_and_value;
   }
   spdy_settings_map->Put(server, settings_map);
 }
 
+AlternateProtocolInfo HttpServerPropertiesManager::ParseAlternateProtocolDict(
+    const base::DictionaryValue& alternate_protocol_dict,
+    const std::string& server_str) {
+  AlternateProtocolInfo alternate_protocol;
+  int port = 0;
+  if (!alternate_protocol_dict.GetInteger(kPortKey, &port) ||
+      !IsPortValid(port)) {
+    DVLOG(1) << "Malformed AltSvc port for server: " << server_str;
+    return alternate_protocol;
+  }
+  alternate_protocol.port = static_cast<uint16>(port);
+
+  double probability = 1.0;
+  if (alternate_protocol_dict.HasKey(kProbabilityKey) &&
+      !alternate_protocol_dict.GetDoubleWithoutPathExpansion(kProbabilityKey,
+                                                             &probability)) {
+    DVLOG(1) << "Malformed AltSvc probability for server: " << server_str;
+    return alternate_protocol;
+  }
+  alternate_protocol.probability = probability;
+
+  std::string protocol_str;
+  if (!alternate_protocol_dict.GetStringWithoutPathExpansion(kProtocolKey,
+                                                             &protocol_str)) {
+    DVLOG(1) << "Malformed AltSvc protocol string for server: " << server_str;
+    return alternate_protocol;
+  }
+  AlternateProtocol protocol = AlternateProtocolFromString(protocol_str);
+  if (!IsAlternateProtocolValid(protocol)) {
+    DVLOG(1) << "Invalid AltSvc protocol string for server: " << server_str;
+    return alternate_protocol;
+  }
+  alternate_protocol.protocol = protocol;
+
+  return alternate_protocol;
+}
+
 bool HttpServerPropertiesManager::AddToAlternateProtocolMap(
     const HostPortPair& server,
     const base::DictionaryValue& server_pref_dict,
     AlternateProtocolMap* alternate_protocol_map) {
   // Get alternate_protocol server.
   DCHECK(alternate_protocol_map->Peek(server) == alternate_protocol_map->end());
-  const base::DictionaryValue* port_alternate_protocol_dict = NULL;
+  const base::DictionaryValue* alternate_protocol_dict = NULL;
   if (!server_pref_dict.GetDictionaryWithoutPathExpansion(
-          kAlternateProtocolKey, &port_alternate_protocol_dict)) {
+          kAlternateProtocolKey, &alternate_protocol_dict)) {
     return true;
   }
-  int port = 0;
-  if (!port_alternate_protocol_dict->GetIntegerWithoutPathExpansion(kPortKey,
-                                                                    &port) ||
-      !IsPortValid(port)) {
-    DVLOG(1) << "Malformed Alternate-Protocol server: " << server.ToString();
+  AlternateProtocolInfo alternate_protocol =
+      ParseAlternateProtocolDict(*alternate_protocol_dict, server.ToString());
+  if (alternate_protocol.protocol == UNINITIALIZED_ALTERNATE_PROTOCOL)
     return false;
-  }
-  std::string protocol_str;
-  if (!port_alternate_protocol_dict->GetStringWithoutPathExpansion(
-          kProtocolKey, &protocol_str)) {
-    DVLOG(1) << "Malformed Alternate-Protocol server: " << server.ToString();
-    return false;
-  }
-  AlternateProtocol protocol = AlternateProtocolFromString(protocol_str);
-  if (!IsAlternateProtocolValid(protocol)) {
-    DVLOG(1) << "Malformed Alternate-Protocol server: " << server.ToString();
-    return false;
-  }
-  double probability = 1;
-  if (port_alternate_protocol_dict->HasKey(kProbabilityKey) &&
-      !port_alternate_protocol_dict->GetDoubleWithoutPathExpansion(
-          kProbabilityKey, &probability)) {
-    DVLOG(1) << "Malformed Alternate-Protocol server: " << server.ToString();
-    return false;
-  }
-
-  AlternateProtocolInfo port_alternate_protocol(static_cast<uint16>(port),
-                                                protocol, probability);
-  alternate_protocol_map->Put(server, port_alternate_protocol);
+  alternate_protocol_map->Put(server, alternate_protocol);
   return true;
 }
 
 bool HttpServerPropertiesManager::ReadSupportsQuic(
     const base::DictionaryValue& http_server_properties_dict,
     IPAddressNumber* last_quic_address) {
   const base::DictionaryValue* supports_quic_dict = NULL;
   if (!http_server_properties_dict.GetDictionaryWithoutPathExpansion(
           kSupportsQuicKey, &supports_quic_dict)) {
     return true;
@@ skipping 351 matching lines @@
                                             server_network_stats_dict);
 }
 
 void HttpServerPropertiesManager::OnHttpServerPropertiesChanged() {
   DCHECK(pref_task_runner_->RunsTasksOnCurrentThread());
   if (!setting_prefs_)
     ScheduleUpdateCacheOnPrefThread();
 }
 
 }  // namespace net