Move string tokenizer to base/strings.

base/debug/trace_event_impl.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 "base/debug/trace_event_impl.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/debug/leak_annotations.h"
 #include "base/debug/trace_event.h"
 #include "base/format_macros.h"
 #include "base/lazy_instance.h"
 #include "base/memory/singleton.h"
 #include "base/process_util.h"
 #include "base/stl_util.h"
+#include "base/string_util.h"
 #include "base/stringprintf.h"
-#include "base/string_tokenizer.h"
-#include "base/string_util.h"
+#include "base/strings/string_tokenizer.h"
 #include "base/sys_info.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread_local.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 
 #if defined(OS_WIN)
 #include "base/debug/trace_event_win.h"
 #endif
@@ skipping 125 matching lines @@
 
   bool arg_is_copy[kTraceMaxNumArgs];
   for (i = 0; i < num_args; ++i) {
     // We only take a copy of arg_vals if they are of type COPY_STRING.
     arg_is_copy[i] = (arg_types_[i] == TRACE_VALUE_TYPE_COPY_STRING);
     if (arg_is_copy[i])
       alloc_size += GetAllocLength(arg_values_[i].as_string);
   }
 
   if (alloc_size) {
-    parameter_copy_storage_ = new base::RefCountedString;
+    parameter_copy_storage_ = new RefCountedString;
     parameter_copy_storage_->data().resize(alloc_size);
     char* ptr = string_as_array(&parameter_copy_storage_->data());
     const char* end = ptr + alloc_size;
     if (copy) {
       CopyTraceEventParameter(&ptr, &name_, end);
       for (i = 0; i < num_args; ++i)
         CopyTraceEventParameter(&ptr, &arg_names_[i], end);
     }
     for (i = 0; i < num_args; ++i) {
       if (arg_is_copy[i])
@@ skipping 96 matching lines @@
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // TraceResultBuffer
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 TraceResultBuffer::OutputCallback
     TraceResultBuffer::SimpleOutput::GetCallback() {
-  return base::Bind(&SimpleOutput::Append, base::Unretained(this));
+  return Bind(&SimpleOutput::Append, Unretained(this));
 }
 
 void TraceResultBuffer::SimpleOutput::Append(
     const std::string& json_trace_output) {
   json_output += json_trace_output;
 }
 
 TraceResultBuffer::TraceResultBuffer() : append_comma_(false) {
 }
 
@@ skipping 65 matching lines @@
   // TODO(jbates): ANNOTATE_BENIGN_RACE_SIZED crashes windows TSAN bots:
   // ANNOTATE_BENIGN_RACE_SIZED(g_category_enabled, sizeof(g_category_enabled),
   //                            "trace_event category enabled");
   for (int i = 0; i < TRACE_EVENT_MAX_CATEGORIES; ++i) {
     ANNOTATE_BENIGN_RACE(&g_category_enabled[i],
                          "trace_event category enabled");
   }
 #if defined(OS_NACL)  // NaCl shouldn't expose the process id.
   SetProcessID(0);
 #else
-  SetProcessID(static_cast<int>(base::GetCurrentProcId()));
+  SetProcessID(static_cast<int>(GetCurrentProcId()));
 #endif
 }
 
 TraceLog::~TraceLog() {
 }
 
 const unsigned char* TraceLog::GetCategoryEnabled(const char* name) {
   TraceLog* tracelog = GetInstance();
   if (!tracelog) {
     DCHECK(!g_category_enabled[g_category_already_shutdown]);
@@ skipping 56 matching lines @@
 
   if (!category_enabled) {
     // Create a new category
     DCHECK(g_category_index < TRACE_EVENT_MAX_CATEGORIES) <<
         "must increase TRACE_EVENT_MAX_CATEGORIES";
     if (g_category_index < TRACE_EVENT_MAX_CATEGORIES) {
       int new_index = g_category_index++;
       // Don't hold on to the name pointer, so that we can create categories
       // with strings not known at compile time (this is required by
       // SetWatchEvent).
-      const char* new_name = base::strdup(name);
+      const char* new_name = strdup(name);
       ANNOTATE_LEAKING_OBJECT_PTR(new_name);
       g_categories[new_index] = new_name;
       DCHECK(!g_category_enabled[new_index]);
       if (enable_count_) {
         // Note that if both included and excluded_categories are empty, the
         // else clause below excludes nothing, thereby enabling this category.
         if (!included_categories_.empty()) {
           EnableMatchingCategory(new_index, included_categories_,
                                  CATEGORY_ENABLED, 0);
         } else {
@@ skipping 194 matching lines @@
     int thread_id = static_cast<int>(PlatformThread::CurrentId());
 
     const char* new_name = PlatformThread::GetName();
     // Check if the thread name has been set or changed since the previous
     // call (if any), but don't bother if the new name is empty. Note this will
     // not detect a thread name change within the same char* buffer address: we
     // favor common case performance over corner case correctness.
     if (new_name != g_current_thread_name.Get().Get() &&
         new_name && *new_name) {
       g_current_thread_name.Get().Set(new_name);
-      base::hash_map<int, std::string>::iterator existing_name =
+      hash_map<int, std::string>::iterator existing_name =
           thread_names_.find(thread_id);
       if (existing_name == thread_names_.end()) {
         // This is a new thread id, and a new name.
         thread_names_[thread_id] = new_name;
       } else {
         // This is a thread id that we've seen before, but potentially with a
         // new name.
-        std::vector<base::StringPiece> existing_names;
+        std::vector<StringPiece> existing_names;
         Tokenize(existing_name->second, ",", &existing_names);
         bool found = std::find(existing_names.begin(),
                                existing_names.end(),
                                new_name) != existing_names.end();
         if (!found) {
           existing_name->second.push_back(',');
           existing_name->second.append(new_name);
         }
       }
     }
@@ skipping 70 matching lines @@
 }
 
 void TraceLog::CancelWatchEvent() {
   AutoLock lock(lock_);
   watch_category_ = NULL;
   watch_event_name_ = "";
 }
 
 void TraceLog::AddThreadNameMetadataEvents() {
   lock_.AssertAcquired();
-  for(base::hash_map<int, std::string>::iterator it = thread_names_.begin();
+  for(hash_map<int, std::string>::iterator it = thread_names_.begin();
       it != thread_names_.end();
       it++) {
     if (!it->second.empty()) {
       int num_args = 1;
       const char* arg_name = "name";
       unsigned char arg_type;
       unsigned long long arg_value;
       trace_event_internal::SetTraceValue(it->second, &arg_type, &arg_value);
       logged_events_.push_back(
           TraceEvent(it->first,
@@ skipping 23 matching lines @@
   unsigned long long pid = static_cast<unsigned long long>(process_id_);
   process_id_hash_ = (offset_basis ^ pid) * fnv_prime;
 }
 
 void TraceLog::SetTimeOffset(TimeDelta offset) {
   time_offset_ = offset;
 }
 
 }  // namespace debug
 }  // namespace base