Make UserScript non-copyable.

extensions/browser/user_script_loader.cc

 // Copyright 2014 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/browser/user_script_loader.h"
 
 #include <stddef.h>
 
 #include <set>
 #include <string>
@@ skipping 11 matching lines @@
 #include "extensions/common/extension_messages.h"
 
 using content::BrowserThread;
 using content::BrowserContext;
 
 namespace extensions {
 
 namespace {
 
 #if DCHECK_IS_ON()
-bool AreScriptsUnique(const UserScriptList& scripts) {
+bool AreScriptsUnique(const BrowserUserScriptList& scripts) {
   std::set<int> script_ids;
-  for (const UserScript& script : scripts) {
-    if (script_ids.count(script.id()))
+  for (const std::unique_ptr<BrowserUserScript>& script : scripts) {
+    if (script_ids.count(script->id()))
       return false;
-    script_ids.insert(script.id());
+    script_ids.insert(script->id());
   }
   return true;
 }
 #endif  // DCHECK_IS_ON()
 
 // Helper function to parse greasesmonkey headers
 bool GetDeclarationValue(const base::StringPiece& line,
                          const base::StringPiece& prefix,
                          std::string* value) {
   base::StringPiece::size_type index = line.find(prefix);
   if (index == base::StringPiece::npos)
     return false;
 
   std::string temp(line.data() + index + prefix.length(),
                    line.length() - index - prefix.length());
 
   if (temp.empty() || !base::IsUnicodeWhitespace(temp[0]))
     return false;
 
   base::TrimWhitespaceASCII(temp, base::TRIM_ALL, value);
   return true;
 }
 
 }  // namespace
 
 // static
 bool UserScriptLoader::ParseMetadataHeader(const base::StringPiece& script_text,
-                                           UserScript* script) {
+                                           BrowserUserScript* script) {
   // http://wiki.greasespot.net/Metadata_block
   base::StringPiece line;
   size_t line_start = 0;
   size_t line_end = line_start;
   bool in_metadata = false;
 
   static const base::StringPiece kUserScriptBegin("// ==UserScript==");
   static const base::StringPiece kUserScriptEng("// ==/UserScript==");
   static const base::StringPiece kNamespaceDeclaration("// @namespace");
   static const base::StringPiece kNameDeclaration("// @name");
@@ skipping 74 matching lines @@
   // If no patterns were specified, default to @include *. This is what
   // Greasemonkey does.
   if (script->globs().empty() && script->url_patterns().is_empty())
     script->add_glob("*");
 
   return true;
 }
 
 UserScriptLoader::UserScriptLoader(BrowserContext* browser_context,
                                    const HostID& host_id)
-    : user_scripts_(new UserScriptList()),
+    : user_scripts_(new BrowserUserScriptList()),
       clear_scripts_(false),
       ready_(false),
       pending_load_(false),
       browser_context_(browser_context),
       host_id_(host_id),
       weak_factory_(this) {
   registrar_.Add(this,
                  content::NOTIFICATION_RENDERER_PROCESS_CREATED,
                  content::NotificationService::AllBrowserContextsAndSources());
 }
 
 UserScriptLoader::~UserScriptLoader() {
   FOR_EACH_OBSERVER(Observer, observers_, OnUserScriptLoaderDestroyed(this));
 }
 
-void UserScriptLoader::AddScripts(const UserScriptList& scripts) {
+void UserScriptLoader::AddScripts(BrowserUserScriptList& scripts) {
 #if DCHECK_IS_ON()
   // |scripts| with non-unique IDs will work, but that would indicate we are
   // doing something wrong somewhere, so DCHECK that.
   DCHECK(AreScriptsUnique(scripts))
       << "AddScripts() expects scripts with unique IDs.";
 #endif  // DCHECK_IS_ON()
-  for (const UserScript& user_script : scripts) {
-    int id = user_script.id();
+  for (std::unique_ptr<BrowserUserScript>& user_script : scripts) {
+    int id = user_script->id();
     removed_script_hosts_.erase(UserScriptIDPair(id));
     if (added_scripts_map_.count(id) == 0)
-      added_scripts_map_[id] = user_script;
+      added_scripts_map_[id] = std::move(user_script);
   }
   AttemptLoad();
 }
 
-void UserScriptLoader::AddScripts(const UserScriptList& scripts,
+void UserScriptLoader::AddScripts(BrowserUserScriptList& scripts,
                                   int render_process_id,
                                   int render_view_id) {
   AddScripts(scripts);
 }
 
 void UserScriptLoader::RemoveScripts(
     const std::set<UserScriptIDPair>& scripts) {
   for (const UserScriptIDPair& id_pair : scripts) {
     removed_script_hosts_.insert(UserScriptIDPair(id_pair.id, id_pair.host_id));
     // TODO(lazyboy): We shouldn't be trying to remove scripts that were never
@@ skipping 48 matching lines @@
 
 void UserScriptLoader::StartLoad() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!is_loading());
 
   // If scripts were marked for clearing before adding and removing, then clear
   // them.
   if (clear_scripts_) {
     user_scripts_->clear();
   } else {
-    for (UserScriptList::iterator it = user_scripts_->begin();
+    for (BrowserUserScriptList::iterator it = user_scripts_->begin();
          it != user_scripts_->end();) {
-      UserScriptIDPair id_pair(it->id());
+      UserScriptIDPair id_pair(it->get()->id());
       if (removed_script_hosts_.count(id_pair) > 0u)
         it = user_scripts_->erase(it);
       else
         ++it;
     }
   }
 
   std::set<int> added_script_ids;
   for (const auto& id_and_script : added_scripts_map_)
-    added_script_ids.insert(id_and_script.second.id());
+    added_script_ids.insert(id_and_script.second->id());
 
   // Expand |changed_hosts_| for OnScriptsLoaded, which will use it in
   // its IPC message. This must be done before we clear |added_scripts_map_| and
   // |removed_script_hosts_| below.
   for (const auto& id_and_script : added_scripts_map_)
-    changed_hosts_.insert(id_and_script.second.host_id());
+    changed_hosts_.insert(id_and_script.second->host_id());
   for (const UserScriptIDPair& id_pair : removed_script_hosts_)
     changed_hosts_.insert(id_pair.host_id);
 
   // Done with |added_scripts_map_|, now put them into |user_scripts_|.
   user_scripts_->reserve(user_scripts_->size() + added_scripts_map_.size());
   for (int id : added_script_ids)
     user_scripts_->push_back(std::move(added_scripts_map_[id]));
 
   LoadScripts(std::move(user_scripts_), changed_hosts_, added_script_ids,
               base::Bind(&UserScriptLoader::OnScriptsLoaded,
                          weak_factory_.GetWeakPtr()));
 
   clear_scripts_ = false;
   added_scripts_map_.clear();
   removed_script_hosts_.clear();
   user_scripts_.reset();
 }
 
 // static
 std::unique_ptr<base::SharedMemory> UserScriptLoader::Serialize(
-    const UserScriptList& scripts) {
+    const BrowserUserScriptList& scripts) {
   base::Pickle pickle;
   pickle.WriteUInt32(scripts.size());
-  for (const UserScript& script : scripts) {
+  for (const std::unique_ptr<BrowserUserScript>& script : scripts) {
     // TODO(aa): This can be replaced by sending content script metadata to
     // renderers along with other extension data in ExtensionMsg_Loaded.
     // See crbug.com/70516.
-    script.Pickle(&pickle);
+    script->Pickle(&pickle);
     // Write scripts as 'data' so that we can read it out in the slave without
     // allocating a new string.
-    for (const UserScript::File& script_file : script.js_scripts()) {
-      base::StringPiece contents = script_file.GetContent();
+    for (const std::unique_ptr<BrowserScriptFile>& script_file :
+         script->js_scripts()) {
+      base::StringPiece contents = script_file->GetContent();
       pickle.WriteData(contents.data(), contents.length());
     }
-    for (const UserScript::File& script_file : script.css_scripts()) {
-      base::StringPiece contents = script_file.GetContent();
+    for (const std::unique_ptr<BrowserScriptFile>& script_file :
+         script->css_scripts()) {
+      base::StringPiece contents = script_file->GetContent();
       pickle.WriteData(contents.data(), contents.length());
     }
   }
 
   // Create the shared memory object.
   base::SharedMemory shared_memory;
 
   base::SharedMemoryCreateOptions options;
   options.size = pickle.size();
   options.share_read_only = true;
@@ skipping 24 matching lines @@
 }
 
 void UserScriptLoader::SetReady(bool ready) {
   bool was_ready = ready_;
   ready_ = ready;
   if (ready_ && !was_ready)
     AttemptLoad();
 }
 
 void UserScriptLoader::OnScriptsLoaded(
-    std::unique_ptr<UserScriptList> user_scripts,
+    std::unique_ptr<BrowserUserScriptList> user_scripts,
     std::unique_ptr<base::SharedMemory> shared_memory) {
   user_scripts_.reset(user_scripts.release());
   if (pending_load_) {
     // While we were loading, there were further changes. Don't bother
     // notifying about these scripts and instead just immediately reload.
     pending_load_ = false;
     StartLoad();
     return;
   }
 
@@ skipping 49 matching lines @@
   if (!shared_memory->ShareToProcess(handle, &handle_for_process))
     return;  // This can legitimately fail if the renderer asserts at startup.
 
   if (base::SharedMemory::IsHandleValid(handle_for_process)) {
     process->Send(new ExtensionMsg_UpdateUserScripts(
         handle_for_process, host_id(), changed_hosts, whitelisted_only));
   }
 }
 
 }  // namespace extensions