Introduce HostID and de-couple Extensions from "script injection System" [browser side]

chrome/browser/extensions/api/declarative_content/content_action.cc

 // Copyright (c) 2012 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/browser/extensions/api/declarative_content/content_action.h"
 
 #include <map>
 
 #include "base/lazy_instance.h"
+#include "base/memory/linked_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/declarative_content/content_constants.h"
 #include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
 #include "chrome/browser/extensions/declarative_user_script_manager.h"
 #include "chrome/browser/extensions/extension_action.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "content/public/browser/invalidate_type.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
+#include "extensions/common/consumer.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_messages.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia.h"
 
 namespace extensions {
 
 namespace keys = declarative_content_constants;
 
 namespace {
@@ skipping 197 matching lines @@
     factory_methods[keys::kRequestContentScript] =
         &RequestContentScript::Create;
     factory_methods[keys::kSetIcon] =
         &SetIcon::Create;
   }
 };
 
 base::LazyInstance<ContentActionFactory>::Leaky
     g_content_action_factory = LAZY_INSTANCE_INITIALIZER;
 
+using RequestContentScriptKey = RequestContentScript::RequestKey;
+
+using RequestContentScriptKeyToIDMap =
+    std::map<RequestContentScriptKey, linked_ptr<ConsumerID>>;

[Devlin, 2015/01/14 16:45:08]

ConsumerIDs are cheap enough to copy that it's not worth the potential agony to
linked_ptr them, since we won't be doing it a lot (especially since
GetConsumerID already returns a const &).  Let's just make this a
map<RequestContentScriptKey, ConsumerID>

[Xi Han, 2015/01/14 23:46:02]

I remember why we have to use the linked_ptr here. If you see line 271, it needs
to call the operator "=" for assigning values, but the auto generated operator =
is deleted since all the fields of ConsumerID are marked as const. 

[Devlin, 2015/01/16 17:05:03]

Dang.  Sorry in advance for this: Let's make ConsumerID a class again. :(

From there, provide operator= and copy constructors for it, and only allow
access to the members by accessor.  This allows for copy/assignment of a
consumer id in STL containers and such, but keeps it, essentially, immutable. 
So sorry for all the back and forth on it :/

The reason to do this is that linked_ptrs really aren't designed to be shared -
they're only really for storing things in an STL container.  And with something
so simple as a ConsumerID, an intricate ownership pattern to avoid copying some
data really isn't worthwhile, unless we find a place where we'll be copying them
hundreds/thousands of meaningless times.  It's much better to just do this
safely than to deal with the segfaults/dereferences/uses-after-free later.

[Xi Han, 2015/01/19 22:40:05]

Done.

+
+// A map of ConsumerIDs for the given RequestContentScript ids.
+// Different types of input ids need to define their own maps to store the
+// mappings from ids to ConsumerIDs.
+static base::LazyInstance<RequestContentScriptKeyToIDMap>

[Devlin, 2015/01/14 16:45:08]

static inside anonymous namespace is redundant -- remove the static.

[Xi Han, 2015/01/14 23:46:02]

Removed.

+      request_content_script_key_to_id_map_ = LAZY_INSTANCE_INITIALIZER;
+

[Devlin, 2015/01/14 16:45:08]

extra newline.

[Xi Han, 2015/01/14 23:46:02]

Oops, removed.

+
+// Looks up and returns the ConsumerID by the given RequestContentScriptKey;
+// if one does not exist, a new object will be created and returned.
+const ConsumerID& GetConsumerID(
+    const RequestContentScriptKey& key,
+    ConsumerID::HostType host_type,
+    ConsumerID::InstanceType instance_type) {
+  RequestContentScriptKeyToIDMap& map =
+      request_content_script_key_to_id_map_.Get();
+  RequestContentScriptKeyToIDMap::iterator it =
+      map.find(key);
+  if (it != map.end())
+    return *(it->second.get());
+
+  linked_ptr<ConsumerID> consumer_id(new ConsumerID(
+      host_type, key.host_id, instance_type, ConsumerID::GetNextID()));
+  map[key] = consumer_id;
+  return *consumer_id;
+}
+
 }  // namespace
 
 //
 // RequestContentScript
 //
 
 struct RequestContentScript::ScriptData {
   ScriptData();
   ~ScriptData();
 
@@ skipping 91 matching lines @@
             &script_data->match_about_blank));
   }
 
   return true;
 }
 
 RequestContentScript::RequestContentScript(
     content::BrowserContext* browser_context,
     const Extension* extension,
     const ScriptData& script_data) {
-  InitScript(extension, script_data);
-
+  const RequestKey key(extension->id());
+  const ConsumerID& consumer_id = GetConsumerID(
+      key, ConsumerID::EXTENSIONS, ConsumerID::TAB);
   master_ = ExtensionSystem::Get(browser_context)
                 ->declarative_user_script_manager()
-                ->GetDeclarativeUserScriptMasterByID(extension->id());
+                ->GetDeclarativeUserScriptMasterByID(consumer_id);
+  InitScript(extension, script_data);
   AddScript();
 }
 
 RequestContentScript::RequestContentScript(
     DeclarativeUserScriptMaster* master,
     const Extension* extension,
     const ScriptData& script_data) {
+  master_.reset(master);
   InitScript(extension, script_data);
-
-  master_ = master;
   AddScript();
 }
 
 RequestContentScript::~RequestContentScript() {
-  DCHECK(master_);
+  DCHECK(master_.get());
   master_->RemoveScript(script_);
 }
 
 void RequestContentScript::InitScript(const Extension* extension,
                                       const ScriptData& script_data) {
   script_.set_id(UserScript::GenerateUserScriptID());
-  script_.set_extension_id(extension->id());
+  script_.set_consumer_id(master_->consumer_id());
   script_.set_run_location(UserScript::BROWSER_DRIVEN);
   script_.set_match_all_frames(script_data.all_frames);
   script_.set_match_about_blank(script_data.match_about_blank);
   for (std::vector<std::string>::const_iterator it =
            script_data.css_file_names.begin();
        it != script_data.css_file_names.end(); ++it) {
     GURL url = extension->GetResourceURL(*it);
     ExtensionResource resource = extension->GetResource(*it);
     script_.css_scripts().push_back(UserScript::File(
         resource.extension_root(), resource.relative_path(), url));
@@ skipping 106 matching lines @@
                              bool* bad_message,
                              const base::DictionaryValue** action_dict,
                              std::string* instance_type) {
   INPUT_FORMAT_VALIDATE(json_action.GetAsDictionary(action_dict));
   INPUT_FORMAT_VALIDATE(
       (*action_dict)->GetString(keys::kInstanceType, instance_type));
   return true;
 }
 
 }  // namespace extensions