Refactor Pickle Read methods to use higher performance PickleIterator.

base/metrics/histogram.h

 // 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.
 
 // Histogram is an object that aggregates statistics, and can summarize them in
 // various forms, including ASCII graphical, HTML, and numerically (as a
 // vector of numbers corresponding to each of the aggregating buckets).
 
 // It supports calls to accumulate either time intervals (which are processed
 // as integral number of milliseconds), or arbitrary integral units.
@@ skipping 36 matching lines @@
 #include <vector>
 
 #include "base/atomicops.h"
 #include "base/base_export.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/logging.h"
 #include "base/time.h"
 
 class Pickle;
+class PickleIterator;
 
 namespace base {
 
 class Lock;
 //------------------------------------------------------------------------------
 // Histograms are often put in areas where they are called many many times, and
 // performance is critical.  As a result, they are designed to have a very low
 // recurring cost of executing (adding additional samples).  Toward that end,
 // the macros declare a static pointer to the histogram in question, and only
 // take a "slow path" to construct (or find) the histogram on the first run
@@ skipping 330 matching lines @@
     Count counts(size_t i) const { return counts_[i]; }
     Count TotalCount() const;
     int64 sum() const { return sum_; }
     int64 redundant_count() const { return redundant_count_; }
 
     // Arithmetic manipulation of corresponding elements of the set.
     void Add(const SampleSet& other);
     void Subtract(const SampleSet& other);
 
     bool Serialize(Pickle* pickle) const;
-    bool Deserialize(void** iter, const Pickle& pickle);
+    bool Deserialize(PickleIterator* iter);
 
    protected:
     // Actual histogram data is stored in buckets, showing the count of values
     // that fit into each bucket.
     Counts counts_;
 
     // Save simple stats locally.  Note that this MIGHT get done in base class
     // without shared memory at some point.
     int64 sum_;         // sum of samples.
 
@@ skipping 332 matching lines @@
   // Helper method for transforming an array of valid enumeration values
   // to the std::vector<int> expected by HISTOGRAM_CUSTOM_ENUMERATION.
   // This function ensures that a guard bucket exists right after any
   // valid sample value (unless the next higher sample is also a valid value),
   // so that invalid samples never fall into the same bucket as valid samples.
   static std::vector<Sample> ArrayToCustomRanges(const Sample* values,
                                                  size_t num_values);
 
   // Helper for deserializing CustomHistograms.  |*ranges| should already be
   // correctly sized before this call.  Return true on success.
-  static bool DeserializeRanges(void** iter, const Pickle& pickle,
+  static bool DeserializeRanges(PickleIterator* iter,
                                 std::vector<Histogram::Sample>* ranges);
 
 
  protected:
   CustomHistogram(const std::string& name,
                   const std::vector<Sample>& custom_ranges);
 
   virtual bool SerializeRanges(Pickle* pickle) const OVERRIDE;
 
   // Initialize ranges_ mapping in cached_ranges_.
@@ skipping 121 matching lines @@
   // of our data, and to quickly see if some other CachedRanges instance is
   // possibly Equal() to this instance.
   uint32 range_checksum_;
 
   DISALLOW_COPY_AND_ASSIGN(CachedRanges);
 };
 
 }  // namespace base
 
 #endif  // BASE_METRICS_HISTOGRAM_H_