DevToolsManagerDelegate: parse all "emulateNetworkConditions" parameters

chrome/browser/devtools/chrome_devtools_manager_delegate.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 "chrome/browser/devtools/chrome_devtools_manager_delegate.h"
 
 #include "base/values.h"
 #include "chrome/browser/devtools/devtools_network_conditions.h"
 #include "chrome/browser/devtools/devtools_network_controller.h"
 #include "chrome/browser/devtools/devtools_protocol.h"
@@ skipping 63 matching lines @@
     return NULL;
   return Profile::FromBrowserContext(host->GetSiteInstance()->GetProcess()->
       GetBrowserContext());
 }
 
 scoped_ptr<DevToolsProtocol::Response>
 ChromeDevToolsManagerDelegate::EmulateNetworkConditions(
     content::DevToolsAgentHost* agent_host,
     DevToolsProtocol::Command* command) {
   base::DictionaryValue* params = command->params();
+
+  std::vector<std::string> domains;
+  base::ListValue* domain_list;
+  const char* domains_param =
+      chrome::devtools::Network::emulateNetworkConditions::kParamDomains;
+  if (!params || !params->GetList(domains_param, &domain_list))
+    return command->InvalidParamResponse(domains_param);
+  size_t size = domain_list->GetSize();
+  for (size_t i = 0; i < size; ++i) {
+    std::string domain;
+    if (!domain_list->GetString(i, &domain))
+      return command->InvalidParamResponse(domains_param);
+    domains.push_back(domain);
+  }
+
   bool offline = false;
   const char* offline_param =
       chrome::devtools::Network::emulateNetworkConditions::kParamOffline;
-  if (!params || !params->GetBoolean(offline_param, &offline))
+  if (!params->GetBoolean(offline_param, &offline))
     return command->InvalidParamResponse(offline_param);
 
+  double maximal_throughput = 0.0;
+  const char* maximal_throughput_param =
+      chrome::devtools::Network::emulateNetworkConditions::kParamMaximalThroughput;
+  if (!params->GetDouble(maximal_throughput_param, &maximal_throughput))
+    return command->InvalidParamResponse(maximal_throughput_param);
+  if (maximal_throughput < 0.0)

[vsevik, 2014/06/06 13:56:54]

nit: I think negative throughput value is actually correct in terms of protocol
(it is a number as required). I don't think we should do semantic checks during
parsing.
We could simply ignore negative throughput values.

[eustas, 2014/06/06 14:48:12]

Done.

+    return command->InvalidParamResponse(maximal_throughput_param);
+
   EnsureDevtoolsCallbackRegistered();
   scoped_refptr<DevToolsNetworkConditions> conditions;
-  if (offline)
-    conditions = new DevToolsNetworkConditions(std::vector<std::string>());
+  if (offline || maximal_throughput)
+    conditions = new DevToolsNetworkConditions(domains, maximal_throughput);
   UpdateNetworkState(agent_host, conditions);
   return command->SuccessResponse(NULL);
 }
 
 void ChromeDevToolsManagerDelegate::UpdateNetworkState(
     content::DevToolsAgentHost* agent_host,
     scoped_refptr<DevToolsNetworkConditions> conditions) {
   Profile* profile = GetProfile(agent_host);
   if (!profile)
     return;
   profile->GetDevToolsNetworkController()->SetNetworkState(
       agent_host->GetId(), conditions);
 }
 
 void ChromeDevToolsManagerDelegate::OnDevToolsStateChanged(
     content::DevToolsAgentHost* agent_host,
     bool attached) {
   UpdateNetworkState(agent_host, scoped_refptr<DevToolsNetworkConditions>());
 }