Make it possible to configure synthetic delays through Devtools

content/browser/devtools/devtools_tracing_handler.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 "content/browser/devtools/devtools_tracing_handler.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "content/browser/devtools/devtools_http_handler_impl.h"
 #include "content/browser/devtools/devtools_protocol_constants.h"
 #include "content/public/browser/trace_controller.h"
 #include "content/public/browser/trace_subscriber.h"
+#include "content/public/browser/tracing_controller.h"
+#include "content/public/browser/tracing_synthetic_delay_configuration.h"
 
 namespace content {
 
 namespace {
 
 const char kRecordUntilFull[]   = "record-until-full";
 const char kRecordContinuously[] = "record-continuously";
 const char kEnableSampling[] = "enable-sampling";
 
 }  // namespace
 
 DevToolsTracingHandler::DevToolsTracingHandler()
     : is_running_(false) {
   RegisterCommandHandler(devtools::Tracing::start::kName,
                          base::Bind(&DevToolsTracingHandler::OnStart,
                                     base::Unretained(this)));
   RegisterCommandHandler(devtools::Tracing::end::kName,
                          base::Bind(&DevToolsTracingHandler::OnEnd,
                                     base::Unretained(this)));
+  RegisterCommandHandler(devtools::Tracing::configureSyntheticDelays::kName,
+                         base::Bind(&DevToolsTracingHandler::
+                                        OnConfigureSyntheticDelays,
+                                    base::Unretained(this)));
 }
 
 DevToolsTracingHandler::~DevToolsTracingHandler() {
 }
 
 void DevToolsTracingHandler::OnEndTracingComplete() {
   is_running_ = false;
   SendNotification(devtools::Tracing::tracingComplete::kName, NULL);
 }
 
@@ skipping 57 matching lines @@
   return command->SuccessResponse(NULL);
 }
 
 scoped_refptr<DevToolsProtocol::Response>
 DevToolsTracingHandler::OnEnd(
     scoped_refptr<DevToolsProtocol::Command> command) {
   TraceController::GetInstance()->EndTracingAsync(this);
   return command->SuccessResponse(NULL);
 }
 
+scoped_refptr<DevToolsProtocol::Response>
+DevToolsTracingHandler::OnConfigureSyntheticDelays(
+    scoped_refptr<DevToolsProtocol::Command> command) {
+  std::string categories;
+  base::DictionaryValue* params = command->params();
+  const base::DictionaryValue* delay_settings;
+  if (params) {
+    params->GetDictionary(devtools::Tracing::configureSyntheticDelays::kDelays,
+                          &delay_settings);
+  }
+
+  if (!delay_settings) {
+    return command->InvalidParamResponse(
+        devtools::Tracing::configureSyntheticDelays::kDelays);
+  }
+
+  std::vector<TracingSyntheticDelayConfiguration> delays;
+  base::DictionaryValue::Iterator it(*delay_settings);
+  while (!it.IsAtEnd()) {
+    TracingSyntheticDelayConfiguration delay;
+    const base::DictionaryValue* properties;
+    if (it.value().GetAsDictionary(&properties)) {
+      double target_duration;
+      if (properties->GetDouble("target_duration", &target_duration)) {
+        delay.target_duration = base::TimeDelta::FromMicroseconds(
+            target_duration * 1e6);
+      }
+      std::string mode;
+      if (properties->GetString("mode", &mode)) {
+        if (mode == "static") {
+          delay.mode = base::debug::TraceEventSyntheticDelay::STATIC;
+        } else if (mode == "oneshot") {
+          delay.mode = base::debug::TraceEventSyntheticDelay::ONE_SHOT;
+        } else if (mode == "alternating") {
+          delay.mode = base::debug::TraceEventSyntheticDelay::ALTERNATING;
+        } else {
+          return command->InvalidParamResponse(
+              devtools::Tracing::configureSyntheticDelays::kDelays);
+        }
+      }
+    }
+    delay.name = it.key();
+    delays.push_back(delay);
+    it.Advance();
+  }
+
+  TracingController::GetInstance()->ConfigureSyntheticDelays(
+      delays,
+      base::Bind(&DevToolsTracingHandler::OnConfigureSyntheticDelaysComplete,
+                 base::Unretained(this)));
+  return command->SuccessResponse(NULL);
+}
+
+void DevToolsTracingHandler::OnConfigureSyntheticDelaysComplete() {
+  SendNotification(devtools::Tracing::configureSyntheticDelaysComplete::kName,
+                   NULL);
+}
+
 }  // namespace content