Make UserScript non-copyable.

extensions/common/user_script.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 "extensions/common/user_script.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/atomic_sequence_num.h"
@@ skipping 77 matching lines @@
 
 UserScript::UserScript()
     : run_location_(DOCUMENT_IDLE),
       consumer_instance_type_(TAB),
       user_script_id_(-1),
       emulate_greasemonkey_(false),
       match_all_frames_(false),
       match_about_blank_(false),
       incognito_enabled_(false) {}
 
-UserScript::UserScript(const UserScript& other) = default;
+UserScript::~UserScript() {
+}
 
-UserScript::~UserScript() {
+// static.
+std::unique_ptr<UserScript> UserScript::CopyFrom(const UserScript& other) {
+  std::unique_ptr<UserScript> script(new UserScript());
+  script->run_location_ = other.run_location_;
+  script->name_space_ = other.name_space_;
+  script->name_ = other.name_;
+  script->description_ = other.description_;
+  script->version_ = other.version_;
+  script->globs_ = other.globs_;
+  script->exclude_globs_ = other.exclude_globs_;
+  script->url_set_ = other.url_set_;
+  script->exclude_url_set_ = other.exclude_url_set_;
+
+  // Note: File content is not copied.

[Devlin, 2016/08/17 16:39:31]

Won't this copy file content?  The copy ctor is default, which would gladly copy
a string.

[lazyboy, 2016/08/17 18:55:52]

Good catch, I've made the copy ctor non-default.

+  for (const std::unique_ptr<File>& file : other.js_scripts()) {
+    std::unique_ptr<File> file_copy(new File(*file));
+    script->js_scripts_.push_back(std::move(file_copy));
+  }
+  for (const std::unique_ptr<File>& file : other.css_scripts()) {
+    std::unique_ptr<File> file_copy(new File(*file));
+    script->css_scripts_.push_back(std::move(file_copy));
+  }
+  script->host_id_ = other.host_id_;
+  script->consumer_instance_type_ = other.consumer_instance_type_;
+  script->user_script_id_ = other.user_script_id_;
+  script->emulate_greasemonkey_ = other.emulate_greasemonkey_;
+  script->match_all_frames_ = other.match_all_frames_;
+  script->match_about_blank_ = other.match_about_blank_;
+  script->incognito_enabled_ = other.incognito_enabled_;
+
+  return script;
 }
 
 void UserScript::add_url_pattern(const URLPattern& pattern) {
   url_set_.AddPattern(pattern);
 }
 
 void UserScript::add_exclude_url_pattern(const URLPattern& pattern) {
   exclude_url_set_.AddPattern(pattern);
 }
 
@@ skipping 75 matching lines @@
   for (URLPatternSet::const_iterator pattern = pattern_list.begin();
        pattern != pattern_list.end(); ++pattern) {
     pickle->WriteInt(pattern->valid_schemes());
     pickle->WriteString(pattern->GetAsString());
   }
 }
 
 void UserScript::PickleScripts(base::Pickle* pickle,
                                const FileList& scripts) const {
   pickle->WriteUInt32(scripts.size());
-  for (FileList::const_iterator file = scripts.begin();
-       file != scripts.end(); ++file) {
+  for (const std::unique_ptr<File>& file : scripts)
     file->Pickle(pickle);
-  }
 }
 
 void UserScript::Unpickle(const base::Pickle& pickle,
                           base::PickleIterator* iter) {
   // Read the run location.
   int run_location = 0;
   CHECK(iter->ReadInt(&run_location));
   CHECK(run_location >= 0 && run_location < RUN_LOCATION_LAST);
   run_location_ = static_cast<RunLocation>(run_location);
 
@@ skipping 65 matching lines @@
   }
 }
 
 void UserScript::UnpickleScripts(const base::Pickle& pickle,
                                  base::PickleIterator* iter,
                                  FileList* scripts) {
   uint32_t num_files = 0;
   CHECK(iter->ReadUInt32(&num_files));
   scripts->clear();
   for (uint32_t i = 0; i < num_files; ++i) {
-    File file;
-    file.Unpickle(pickle, iter);
-    scripts->push_back(file);
+    std::unique_ptr<File> file(new File());
+    file->Unpickle(pickle, iter);
+    scripts->push_back(std::move(file));
   }
 }
 
 UserScriptIDPair::UserScriptIDPair(int id, const HostID& host_id)
     : id(id), host_id(host_id) {}
 
 UserScriptIDPair::UserScriptIDPair(int id) : id(id), host_id(HostID()) {}
 
 bool operator<(const UserScriptIDPair& a, const UserScriptIDPair& b) {
   return a.id < b.id;
 }
 
-bool operator<(const UserScript& script1, const UserScript& script2) {
-  // The only kind of script that should be compared is the kind that has its
-  // IDs initialized to a meaningful value.
-  DCHECK(script1.id() != -1 && script2.id() != -1);
-  return script1.id() < script2.id();
-}
-
 }  // namespace extensions