Rework some UserScriptLoader logic in preparation to removing UserScript copy.

extensions/browser/guest_view/web_view/web_view_content_script_manager.cc

 // Copyright 2015 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/guest_view/web_view/web_view_content_script_manager.h"
 
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/render_frame_host.h"
@@ skipping 28 matching lines @@
                                  manager);
   }
   return manager;
 }
 
 void WebViewContentScriptManager::AddContentScripts(
     int embedder_process_id,
     content::RenderFrameHost* render_frame_host,
     int view_instance_id,
     const HostID& host_id,
-    const std::set<UserScript>& scripts) {
+    const UserScriptList& scripts) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   DeclarativeUserScriptMaster* master =
       DeclarativeUserScriptManager::Get(browser_context_)
           ->GetDeclarativeUserScriptMasterByID(host_id);
   DCHECK(master);
 
   // We need to update WebViewRenderState in the IO thread if the guest exists.
   std::set<int> ids_to_add;
 
   GuestMapKey key = std::pair<int, int>(embedder_process_id, view_instance_id);
   GuestContentScriptMap::iterator iter = guest_content_script_map_.find(key);
 
   // Step 1: finds the entry in guest_content_script_map_ by the given |key|.
   // If there isn't any content script added for the given guest yet, insert an
   // empty map first.
   if (iter == guest_content_script_map_.end()) {
     iter = guest_content_script_map_.insert(
         iter,
         std::pair<GuestMapKey, ContentScriptMap>(key, ContentScriptMap()));
   }
 
   // Step 2: updates the guest_content_script_map_.
   ContentScriptMap& map = iter->second;
-  std::set<UserScript> scripts_to_delete;
+  std::set<UserScriptIDPair> to_delete;
   for (const UserScript& script : scripts) {
     auto map_iter = map.find(script.name());
     // If a content script has the same name as the new one, remove the old
     // script first, and insert the new one.
     if (map_iter != map.end()) {
-      scripts_to_delete.insert(map_iter->second);
+      to_delete.insert(map_iter->second);
       map.erase(map_iter);
     }
-    map.insert(std::pair<std::string, UserScript>(script.name(), script));
+    map.insert(std::pair<std::string, UserScriptIDPair>(
+        script.name(), UserScriptIDPair(script.id(), script.host_id())));
     ids_to_add.insert(script.id());
   }
-
-  if (!scripts_to_delete.empty()) {
-    master->RemoveScripts(scripts_to_delete);
-  }
+  if (!to_delete.empty())
+    master->RemoveScripts(to_delete);
 
   // Step 3: makes WebViewContentScriptManager become an observer of the
   // |loader| for scripts loaded event.
   UserScriptLoader* loader = master->loader();
   DCHECK(loader);
   if (!user_script_loader_observer_.IsObserving(loader))
     user_script_loader_observer_.Add(loader);
 
   // Step 4: adds new scripts to the master.
   master->AddScripts(scripts, embedder_process_id,
@@ skipping 49 matching lines @@
   if (script_map_iter == guest_content_script_map_.end())
     return;
 
   DeclarativeUserScriptMaster* master =
       DeclarativeUserScriptManager::Get(browser_context_)
           ->GetDeclarativeUserScriptMasterByID(host_id);
   CHECK(master);
 
   // We need to update WebViewRenderState in the IO thread if the guest exists.
   std::set<int> ids_to_delete;
-  std::set<UserScript> scripts_to_delete;
+  std::set<UserScriptIDPair> scripts_to_delete;
 
   // Step 1: removes content scripts from |master| and updates
   // |guest_content_script_map_|.
-  std::map<std::string, UserScript>& map = script_map_iter->second;
+  std::map<std::string, UserScriptIDPair>& map = script_map_iter->second;
   // If the |script_name_list| is empty, all the content scripts added by the
   // guest will be removed; otherwise, removes the scripts in the
   // |script_name_list|.
   if (script_name_list.empty()) {
     auto it = map.begin();
     while (it != map.end()) {
       scripts_to_delete.insert(it->second);
-      ids_to_delete.insert(it->second.id());
+      ids_to_delete.insert(it->second.id);
       map.erase(it++);
     }
   } else {
     for (const std::string& name : script_name_list) {
       ContentScriptMap::iterator iter = map.find(name);
       if (iter == map.end())
         continue;
-      const UserScript& script = iter->second;
-      ids_to_delete.insert(script.id());
-      scripts_to_delete.insert(script);
+      const UserScriptIDPair& id_pair = iter->second;
+      ids_to_delete.insert(id_pair.id);
+      scripts_to_delete.insert(id_pair);
       map.erase(iter);
     }
   }
 
   // Step 2: makes WebViewContentScriptManager become an observer of the
   // |loader| for scripts loaded event.
   UserScriptLoader* loader = master->loader();
   DCHECK(loader);
   if (!user_script_loader_observer_.IsObserving(loader))
     user_script_loader_observer_.Add(loader);
@@ skipping 15 matching lines @@
     int embedder_process_id,
     int view_instance_id) {
   std::set<int> ids;
 
   GuestMapKey key = std::pair<int, int>(embedder_process_id, view_instance_id);
   GuestContentScriptMap::const_iterator iter =
       guest_content_script_map_.find(key);
   if (iter == guest_content_script_map_.end())
     return ids;
   const ContentScriptMap& map = iter->second;
-  for (const auto& pair : map)
-    ids.insert(pair.second.id());
+  for (const auto& id_pair : map)
+    ids.insert(id_pair.second.id);
 
   return ids;
 }
 
 void WebViewContentScriptManager::SignalOnScriptsLoaded(
     const base::Closure& callback) {
   if (!user_script_loader_observer_.IsObservingSources()) {
     callback.Run();
     return;
   }
@@ skipping 13 matching lines @@
 
 void WebViewContentScriptManager::RunCallbacksIfReady() {
   if (user_script_loader_observer_.IsObservingSources())
     return;
   for (auto& callback : pending_scripts_loading_callbacks_)
     callback.Run();
   pending_scripts_loading_callbacks_.clear();
 }
 
 }  // namespace extensions