Update SplitString calls in components

components/metrics/serialization/metric_sample.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 "components/metrics/serialization/metric_sample.h"
 
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
@@ skipping 100 matching lines @@
     int min,
     int max,
     int bucket_count) {
   return scoped_ptr<MetricSample>(new MetricSample(
       HISTOGRAM, histogram_name, sample, min, max, bucket_count));
 }
 
 // static
 scoped_ptr<MetricSample> MetricSample::ParseHistogram(
     const std::string& serialized_histogram) {
-  std::vector<std::string> parts;
-  base::SplitString(serialized_histogram, ' ', &parts);
+  std::vector<base::StringPiece> parts = base::SplitStringPiece(
+      serialized_histogram, " ", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
 
   if (parts.size() != 5)
     return scoped_ptr<MetricSample>();
   int sample, min, max, bucket_count;
   if (parts[0].empty() || !base::StringToInt(parts[1], &sample) ||
       !base::StringToInt(parts[2], &min) ||
       !base::StringToInt(parts[3], &max) ||
       !base::StringToInt(parts[4], &bucket_count)) {
     return scoped_ptr<MetricSample>();
   }
 
-  return HistogramSample(parts[0], sample, min, max, bucket_count);
+  return HistogramSample(parts[0].as_string(), sample, min, max, bucket_count);
 }
 
 // static
 scoped_ptr<MetricSample> MetricSample::SparseHistogramSample(
     const std::string& histogram_name,
     int sample) {
   return scoped_ptr<MetricSample>(
       new MetricSample(SPARSE_HISTOGRAM, histogram_name, sample, 0, 0, 0));
 }
 
 // static
 scoped_ptr<MetricSample> MetricSample::ParseSparseHistogram(
     const std::string& serialized_histogram) {
-  std::vector<std::string> parts;
-  base::SplitString(serialized_histogram, ' ', &parts);
+  std::vector<base::StringPiece> parts = base::SplitStringPiece(
+      serialized_histogram, " ", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
   if (parts.size() != 2)
     return scoped_ptr<MetricSample>();
   int sample;
   if (parts[0].empty() || !base::StringToInt(parts[1], &sample))
     return scoped_ptr<MetricSample>();
 
-  return SparseHistogramSample(parts[0], sample);
+  return SparseHistogramSample(parts[0].as_string(), sample);
 }
 
 // static
 scoped_ptr<MetricSample> MetricSample::LinearHistogramSample(
     const std::string& histogram_name,
     int sample,
     int max) {
   return scoped_ptr<MetricSample>(
       new MetricSample(LINEAR_HISTOGRAM, histogram_name, sample, 0, max, 0));
 }
 
 // static
 scoped_ptr<MetricSample> MetricSample::ParseLinearHistogram(
     const std::string& serialized_histogram) {
-  std::vector<std::string> parts;
+  std::vector<base::StringPiece> parts = base::SplitStringPiece(
+      serialized_histogram, " ", base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
   int sample, max;
-  base::SplitString(serialized_histogram, ' ', &parts);
   if (parts.size() != 3)
     return scoped_ptr<MetricSample>();
   if (parts[0].empty() || !base::StringToInt(parts[1], &sample) ||
       !base::StringToInt(parts[2], &max)) {
     return scoped_ptr<MetricSample>();
   }
 
-  return LinearHistogramSample(parts[0], sample, max);
+  return LinearHistogramSample(parts[0].as_string(), sample, max);
 }
 
 // static
 scoped_ptr<MetricSample> MetricSample::UserActionSample(
     const std::string& action_name) {
   return scoped_ptr<MetricSample>(
       new MetricSample(USER_ACTION, action_name, 0, 0, 0, 0));
 }
 
 bool MetricSample::IsEqual(const MetricSample& metric) {
   return type_ == metric.type_ && name_ == metric.name_ &&
          sample_ == metric.sample_ && min_ == metric.min_ &&
          max_ == metric.max_ && bucket_count_ == metric.bucket_count_;
 }
 
 }  // namespace metrics