Update //base to chromium 9659b08ea5a34f889dc4166217f438095ddc10d2

base/trace_event/trace_event_memory.cc

 // Copyright 2013 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/trace_event/trace_event_memory.h"
 
 #include "base/debug/leak_annotations.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_local_storage.h"
 #include "base/trace_event/trace_event.h"
 
 namespace base {
 namespace trace_event {
 
 namespace {
 
 // Maximum number of nested TRACE_EVENT scopes to record. Must be less than
@@ skipping 287 matching lines @@
   //
   // Skip input after MAPPED_LIBRARIES.
   std::string input_string;
   const char* mapped_libraries = strstr(input, "MAPPED_LIBRARIES");
   if (mapped_libraries) {
     input_string.assign(input, mapped_libraries - input);
   } else {
     input_string.assign(input);
   }
 
-  std::vector<std::string> lines;
-  size_t line_count = Tokenize(input_string, "\n", &lines);
-  if (line_count == 0) {
+  std::vector<std::string> lines = base::SplitString(
+      input_string, "\n", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
+  if (lines.empty()) {
     DLOG(WARNING) << "No lines found";
     return;
   }
 
   // Handle the initial summary line.
   output->append("[");
   AppendHeapProfileTotalsAsTraceFormat(lines[0], output);
 
   // Handle the following stack trace lines.
-  for (size_t i = 1; i < line_count; ++i) {
-    const std::string& line = lines[i];
-    AppendHeapProfileLineAsTraceFormat(line, output);
-  }
+  for (size_t i = 1; i < lines.size(); i++)
+    AppendHeapProfileLineAsTraceFormat(lines[i], output);
   output->append("]\n");
 }
 
 void AppendHeapProfileTotalsAsTraceFormat(const std::string& line,
                                           std::string* output) {
   // This is what a line looks like:
   // heap profile:    357:    55227 [ 14653:  2624014] @ heapprofile
   //
   // The numbers represent total allocations since profiling was enabled.
   // From the example above:
   //     357 = Outstanding allocations (mallocs - frees)
   //   55227 = Outstanding bytes (malloc bytes - free bytes)
   //   14653 = Total allocations (mallocs)
   // 2624014 = Total bytes (malloc bytes)
-  std::vector<std::string> tokens;
-  Tokenize(line, " :[]@", &tokens);
+  std::vector<std::string> tokens = base::SplitString(
+      line, " :[]@", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
   if (tokens.size() < 4) {
     DLOG(WARNING) << "Invalid totals line " << line;
     return;
   }
   DCHECK_EQ(tokens[0], "heap");
   DCHECK_EQ(tokens[1], "profile");
   output->append("{\"current_allocs\": ");
   output->append(tokens[2]);
   output->append(", \"current_bytes\": ");
   output->append(tokens[3]);
   output->append(", \"trace\": \"\"}");
 }
 
 bool AppendHeapProfileLineAsTraceFormat(const std::string& line,
                                         std::string* output) {
   // This is what a line looks like:
   //    68:     4195 [  1087:    98009] @ 0x7fa7fa9b9ba0 0x7fa7f4b3be13
   //
   // The numbers represent allocations for a particular stack trace since
   // profiling was enabled. From the example above:
   //    68 = Outstanding allocations (mallocs - frees)
   //  4195 = Outstanding bytes (malloc bytes - free bytes)
   //  1087 = Total allocations (mallocs)
   // 98009 = Total bytes (malloc bytes)
   //
   // 0x7fa7fa9b9ba0 0x7fa7f4b3be13 = Stack trace represented as pointers to
   //                                 static strings from trace event categories
   //                                 and names.
-  std::vector<std::string> tokens;
-  Tokenize(line, " :[]@", &tokens);
+  std::vector<std::string> tokens = base::SplitString(
+      line, " :[]@", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
   // It's valid to have no stack addresses, so only require 4 tokens.
   if (tokens.size() < 4) {
     DLOG(WARNING) << "Invalid line " << line;
     return false;
   }
   // Don't bother with stacks that have no current allocations.
   if (tokens[0] == "0")
     return false;
   output->append(",\n");
   output->append("{\"current_allocs\": ");
@@ skipping 35 matching lines @@
   if (!base::HexStringToUInt64(hex_address, &address))
     return "error";
   if (!address)
     return "null";
   // Note that this cast handles 64-bit to 32-bit conversion if necessary.
   return reinterpret_cast<const char*>(address);
 }
 
 }  // namespace trace_event
 }  // namespace base