Refactor Pickle Read methods to use higher performance PickleIterator.

chrome/common/extensions/user_script.cc

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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 "chrome/common/extensions/user_script.h"
 
 #include "base/pickle.h"
 #include "base/string_util.h"
 
 namespace {
 
@@ skipping 70 matching lines @@
 
   return true;
 }
 
 void UserScript::File::Pickle(::Pickle* pickle) const {
   pickle->WriteString(url_.spec());
   // Do not write path. It's not needed in the renderer.
   // Do not write content. It will be serialized by other means.
 }
 
-void UserScript::File::Unpickle(const ::Pickle& pickle, void** iter) {
+void UserScript::File::Unpickle(const ::Pickle& pickle, PickleIterator* iter) {
   // Read the url from the pickle.
   std::string url;
   CHECK(pickle.ReadString(iter, &url));
   set_url(GURL(url));
 }
 
 void UserScript::Pickle(::Pickle* pickle) const {
   // Write the simple types to the pickle.
   pickle->WriteInt(run_location());
   pickle->WriteString(extension_id());
@@ skipping 30 matching lines @@
 
 void UserScript::PickleScripts(::Pickle* pickle,
                                const FileList& scripts) const {
   pickle->WriteSize(scripts.size());
   for (FileList::const_iterator file = scripts.begin();
        file != scripts.end(); ++file) {
     file->Pickle(pickle);
   }
 }
 
-void UserScript::Unpickle(const ::Pickle& pickle, void** iter) {
+void UserScript::Unpickle(const ::Pickle& pickle, PickleIterator* iter) {
   // Read the run location.
   int run_location = 0;
   CHECK(pickle.ReadInt(iter, &run_location));
   CHECK(run_location >= 0 && run_location < RUN_LOCATION_LAST);
   run_location_ = static_cast<RunLocation>(run_location);
 
   CHECK(pickle.ReadString(iter, &extension_id_));
   CHECK(pickle.ReadBool(iter, &emulate_greasemonkey_));
   CHECK(pickle.ReadBool(iter, &match_all_frames_));
   CHECK(pickle.ReadBool(iter, &incognito_enabled_));
 
   UnpickleGlobs(pickle, iter, &globs_);
   UnpickleGlobs(pickle, iter, &exclude_globs_);
   UnpickleURLPatternSet(pickle, iter, &url_set_);
   UnpickleURLPatternSet(pickle, iter, &exclude_url_set_);
   UnpickleScripts(pickle, iter, &js_scripts_);
   UnpickleScripts(pickle, iter, &css_scripts_);
 }
 
-void UserScript::UnpickleGlobs(const ::Pickle& pickle, void** iter,
+void UserScript::UnpickleGlobs(const ::Pickle& pickle, PickleIterator* iter,
                                std::vector<std::string>* globs) {
   size_t num_globs = 0;
   CHECK(pickle.ReadSize(iter, &num_globs));
   globs->clear();
   for (size_t i = 0; i < num_globs; ++i) {
     std::string glob;
     CHECK(pickle.ReadString(iter, &glob));
     globs->push_back(glob);
   }
 }
 
-void UserScript::UnpickleURLPatternSet(const ::Pickle& pickle, void** iter,
+void UserScript::UnpickleURLPatternSet(const ::Pickle& pickle,
+                                       PickleIterator* iter,
                                        URLPatternSet* pattern_list) {
   size_t num_patterns = 0;
   CHECK(pickle.ReadSize(iter, &num_patterns));
 
   pattern_list->ClearPatterns();
   for (size_t i = 0; i < num_patterns; ++i) {
     int valid_schemes;
     CHECK(pickle.ReadInt(iter, &valid_schemes));
     std::string pattern_str;
     URLPattern pattern(valid_schemes);
     CHECK(pickle.ReadString(iter, &pattern_str));
 
     // We remove the file scheme if it's not actually allowed (see Extension::
     // LoadUserScriptHelper), but we need it temporarily while loading the
     // pattern so that it's valid.
     bool had_file_scheme = (valid_schemes & URLPattern::SCHEME_FILE) != 0;
     if (!had_file_scheme)
       pattern.SetValidSchemes(valid_schemes | URLPattern::SCHEME_FILE);
     CHECK(URLPattern::PARSE_SUCCESS == pattern.Parse(pattern_str));
     if (!had_file_scheme)
       pattern.SetValidSchemes(valid_schemes);
 
     pattern_list->AddPattern(pattern);
   }
 }
 
-void UserScript::UnpickleScripts(const ::Pickle& pickle, void** iter,
+void UserScript::UnpickleScripts(const ::Pickle& pickle, PickleIterator* iter,
                                  FileList* scripts) {
   size_t num_files = 0;
   CHECK(pickle.ReadSize(iter, &num_files));
   scripts->clear();
   for (size_t i = 0; i < num_files; ++i) {
     File file;
     file.Unpickle(pickle, iter);
     scripts->push_back(file);
   }
 }