Make UserScript non-copyable.

extensions/common/user_script.h

 // 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.
 
 #ifndef EXTENSIONS_COMMON_USER_SCRIPT_H_
 #define EXTENSIONS_COMMON_USER_SCRIPT_H_
 
 #include <string>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/strings/string_piece.h"
 #include "extensions/common/host_id.h"
 #include "extensions/common/url_pattern.h"
 #include "extensions/common/url_pattern_set.h"
 #include "url/gurl.h"
 
 namespace base {
 class Pickle;
 class PickleIterator;
 }
 
 namespace extensions {
 
 // Represents a user script, either a standalone one, or one that is part of an
 // extension.
+// Contains information related to user scripts, either a standalone one, or one
+// that is part of an extension.
+// This class also contains script file (JS/CSS) related information, but not
+// their file contents.

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

outdated, right?

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

Yes, fixed.

 class UserScript {
  public:
   // The file extension for standalone user scripts.
   static const char kFileExtension[];
 
   static int GenerateUserScriptID();
 
   // Check if a URL should be treated as a user script and converted to an
   // extension.
   static bool IsURLUserScript(const GURL& url, const std::string& mime_type);
@@ skipping 29 matching lines @@
                     // is "idle". Currently this uses the simple heuristic of:
                     // min(DOM_CONTENT_LOADED + TIMEOUT, ONLOAD), but no
                     // particular injection point is guaranteed.
     RUN_DEFERRED,  // The user script's injection was deferred for permissions
                    // reasons, and was executed at a later time.
     BROWSER_DRIVEN,  // The user script will be injected when triggered by an
                      // IPC in the browser process.
     RUN_LOCATION_LAST  // Leave this as the last item.
   };
 
-  // Holds actual script file info.
+  // Holds script file info.
   class File {
    public:
     File(const base::FilePath& extension_root,
          const base::FilePath& relative_path,
          const GURL& url);
     File();
     File(const File& other);
     ~File();
 
     const base::FilePath& extension_root() const { return extension_root_; }
@@ skipping 32 matching lines @@
     GURL url_;
 
     // The script content. It can be set to either loaded_content_ or
     // externally allocated string.
     base::StringPiece external_content_;
 
     // Set when the content is loaded by LoadContent
     std::string content_;
   };
 
-  typedef std::vector<File> FileList;
+  using FileList = std::vector<std::unique_ptr<File>>;
 
   // Type of a API consumer instance that user scripts will be injected on.
   enum ConsumerInstanceType { TAB, WEBVIEW };
 
   // Constructor. Default the run location to document end, which is like
   // Greasemonkey and probably more useful for typical scripts.
   UserScript();
-  UserScript(const UserScript& other);
   ~UserScript();
 
+  // Peforms a copy of all fields.
+  static std::unique_ptr<UserScript> CopyFrom(const UserScript& other);
+
   const std::string& name_space() const { return name_space_; }
   void set_name_space(const std::string& name_space) {
     name_space_ = name_space;
   }
 
   const std::string& name() const { return name_; }
   void set_name(const std::string& name) { name_ = name; }
 
   const std::string& version() const { return version_; }
   void set_version(const std::string& version) {
@@ skipping 67 matching lines @@
   int id() const { return user_script_id_; }
   void set_id(int id) { user_script_id_ = id; }
 
   bool is_incognito_enabled() const { return incognito_enabled_; }
   void set_incognito_enabled(bool enabled) { incognito_enabled_ = enabled; }
 
   // Returns true if the script should be applied to the specified URL, false
   // otherwise.
   bool MatchesURL(const GURL& url) const;
 
-  // Serialize the UserScript into a pickle. The content of the scripts and
+  // Serializes the UserScript into a pickle. The content of the scripts and
   // paths to UserScript::Files will not be serialized!
   void Pickle(base::Pickle* pickle) const;
 
-  // Deserialize the script from a pickle. Note that this always succeeds
+  // Deserializes the script from a pickle. Note that this always succeeds
   // because presumably we were the one that pickled it, and we did it
   // correctly.
   void Unpickle(const base::Pickle& pickle, base::PickleIterator* iter);
 
  private:
   // base::Pickle helper functions used to pickle the individual types of
   // components.
   void PickleGlobs(base::Pickle* pickle,
                    const std::vector<std::string>& globs) const;
   void PickleHostID(base::Pickle* pickle, const HostID& host_id) const;
@@ skipping 66 matching lines @@
   // Whether the user script should run in all frames, or only just the top one.
   // Defaults to false.
   bool match_all_frames_;
 
   // Whether the user script should run in about:blank and about:srcdoc as well.
   // Defaults to false.
   bool match_about_blank_;
 
   // True if the script should be injected into an incognito tab.
   bool incognito_enabled_;
+
+ private:

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

this already is private:, right?

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

Done.

+  DISALLOW_COPY_AND_ASSIGN(UserScript);
 };
 
 // Information we need while removing scripts from a UserScriptLoader.
 struct UserScriptIDPair {
   UserScriptIDPair(int id, const HostID& host_id);
   UserScriptIDPair(int id);
 
   int id;
   HostID host_id;
 };
 
-// For storing UserScripts with unique IDs in sets.
-bool operator<(const UserScript& script1, const UserScript& script2);
-
 bool operator<(const UserScriptIDPair& a, const UserScriptIDPair& b);
 
-typedef std::vector<UserScript> UserScriptList;
+using UserScriptList = std::vector<std::unique_ptr<UserScript>>;
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_COMMON_USER_SCRIPT_H_