Update URLPatternSet to contain a std::set instead of std::vector.

chrome/common/extensions/extension_messages.cc

 // Copyright (c) 2011 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/extension_messages.h"
 
 #include "chrome/common/extensions/extension_constants.h"
 #include "content/common/common_param_traits.h"
 
 ExtensionMsg_Loaded_Params::ExtensionMsg_Loaded_Params()
@@ skipping 81 matching lines @@
 }
 
 bool ParamTraits<URLPattern>::Read(const Message* m, void** iter,
                                    param_type* p) {
   int valid_schemes;
   std::string spec;
   if (!ReadParam(m, iter, &valid_schemes) ||
       !ReadParam(m, iter, &spec))
     return false;
 
-  p->set_valid_schemes(valid_schemes);
+  p->SetValidSchemes(valid_schemes);
   return URLPattern::PARSE_SUCCESS == p->Parse(spec, URLPattern::IGNORE_PORTS);
 }
 
 void ParamTraits<URLPattern>::Log(const param_type& p, std::string* l) {
   LogParam(p.GetAsString(), l);
 }
 
 void ParamTraits<URLPatternSet>::Write(Message* m, const param_type& p) {
   WriteParam(m, p.patterns());
 }
 
 bool ParamTraits<URLPatternSet>::Read(const Message* m, void** iter,
                                         param_type* p) {
-  URLPatternList patterns;
+  std::set<URLPattern> patterns;
   bool success =
       ReadParam(m, iter, &patterns);
   if (!success)
     return false;
 
-  for (size_t i = 0; i < patterns.size(); ++i)
-    p->AddPattern(patterns[i]);
+  for (std::set<URLPattern>::iterator i = patterns.begin();
+       i != patterns.end(); ++i)
+    p->AddPattern(*i);
   return true;
 }
 
 void ParamTraits<URLPatternSet>::Log(const param_type& p, std::string* l) {
   LogParam(p.patterns(), l);
 }
 
 void ParamTraits<ExtensionMsg_Loaded_Params>::Write(Message* m,
                                                     const param_type& p) {
   WriteParam(m, p.location);
   WriteParam(m, p.path);
   WriteParam(m, *(p.manifest));
 }
 
 bool ParamTraits<ExtensionMsg_Loaded_Params>::Read(const Message* m,
                                                    void** iter,
                                                    param_type* p) {
   p->manifest.reset(new DictionaryValue());
   return ReadParam(m, iter, &p->location) &&
          ReadParam(m, iter, &p->path) &&
          ReadParam(m, iter, p->manifest.get());
 }
 
 void ParamTraits<ExtensionMsg_Loaded_Params>::Log(const param_type& p,
                                                   std::string* l) {
   l->append(p.id);
 }
 
 }  // namespace IPC