Mechanical rename of base::debug -> base::trace_event for /content

content/browser/devtools/protocol/tracing_handler.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 "content/browser/devtools/protocol/tracing_handler.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/strings/string_split.h"
@@ skipping 73 matching lines @@
 }
 
 Response TracingHandler::Start(DevToolsCommandId command_id,
                                const std::string* categories,
                                const std::string* options_str,
                                const double* buffer_usage_reporting_interval) {
   if (is_recording_)
     return Response::InternalError("Tracing is already started");
 
   is_recording_ = true;
-  base::debug::TraceOptions options = TraceOptionsFromString(options_str);
-  base::debug::CategoryFilter filter(categories ? *categories : std::string());
+  base::trace_event::TraceOptions options = TraceOptionsFromString(options_str);
+  base::trace_event::CategoryFilter filter(categories ? *categories
+                                                      : std::string());
   if (buffer_usage_reporting_interval)
     SetupTimer(*buffer_usage_reporting_interval);
 
   // If inspected target is a render process Tracing.start will be handled by
   // tracing agent in the renderer.
   if (target_ == Renderer) {
     TracingController::GetInstance()->EnableRecording(
         filter,
         options,
         TracingController::EnableRecordingDoneCallback());
@@ skipping 44 matching lines @@
 void TracingHandler::OnCategoriesReceived(
     DevToolsCommandId command_id,
     const std::set<std::string>& category_set) {
   std::vector<std::string> categories;
   for (const std::string& category : category_set)
     categories.push_back(category);
   client_->SendGetCategoriesResponse(command_id,
       GetCategoriesResponse::Create()->set_categories(categories));
 }
 
-base::debug::TraceOptions TracingHandler::TraceOptionsFromString(
+base::trace_event::TraceOptions TracingHandler::TraceOptionsFromString(
     const std::string* options) {
-  base::debug::TraceOptions ret;
+  base::trace_event::TraceOptions ret;
   if (!options)
     return ret;
 
   std::vector<std::string> split;
   std::vector<std::string>::iterator iter;
 
   base::SplitString(*options, ',', &split);
   for (iter = split.begin(); iter != split.end(); ++iter) {
     if (*iter == kRecordUntilFull) {
-      ret.record_mode = base::debug::RECORD_UNTIL_FULL;
+      ret.record_mode = base::trace_event::RECORD_UNTIL_FULL;
     } else if (*iter == kRecordContinuously) {
-      ret.record_mode = base::debug::RECORD_CONTINUOUSLY;
+      ret.record_mode = base::trace_event::RECORD_CONTINUOUSLY;
     } else if (*iter == kRecordAsMuchAsPossible) {
-      ret.record_mode = base::debug::RECORD_AS_MUCH_AS_POSSIBLE;
+      ret.record_mode = base::trace_event::RECORD_AS_MUCH_AS_POSSIBLE;
     } else if (*iter == kEnableSampling) {
       ret.enable_sampling = true;
     }
   }
   return ret;
 }
 
 void TracingHandler::SetupTimer(double usage_reporting_interval) {
   if (usage_reporting_interval == 0) return;
 
@@ skipping 15 matching lines @@
 void TracingHandler::DisableRecording(bool abort) {
   is_recording_ = false;
   buffer_usage_poll_timer_.reset();
   TracingController::GetInstance()->DisableRecording(
       abort ? nullptr : new DevToolsTraceSinkProxy(weak_factory_.GetWeakPtr()));
 }
 
 }  // namespace tracing
 }  // namespace devtools
 }  // namespace content