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

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 "base/atomic_sequence_num.h"
 #include "base/command_line.h"
 #include "base/pickle.h"
 #include "base/strings/string_util.h"
@@ skipping 67 matching lines @@
 UserScript::File::File() {}
 
 UserScript::File::~File() {}
 
 UserScript::UserScript()
     : run_location_(DOCUMENT_IDLE),
       user_script_id_(-1),
       emulate_greasemonkey_(false),
       match_all_frames_(false),
       match_about_blank_(false),
-      incognito_enabled_(false) {}
+      incognito_enabled_(false) {
+}
 
 UserScript::~UserScript() {
 }
 
+const std::string& UserScript::GetExtensionID() const {
+  DCHECK(consumer_id_.get());
+  return consumer_id_->host_id();
+}
+
 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);
 }
 
 bool UserScript::MatchesURL(const GURL& url) const {
   if (!url_set_.is_empty()) {
@@ skipping 28 matching lines @@
 void UserScript::File::Unpickle(const ::Pickle& pickle, PickleIterator* iter) {
   // Read the url from the pickle.
   std::string url;
   CHECK(iter->ReadString(&url));
   set_url(GURL(url));
 }
 
 void UserScript::Pickle(::Pickle* pickle) const {
   // Write the simple types to the pickle.
   pickle->WriteInt(run_location());
-  pickle->WriteString(extension_id());
   pickle->WriteInt(user_script_id_);
   pickle->WriteBool(emulate_greasemonkey());
   pickle->WriteBool(match_all_frames());
   pickle->WriteBool(match_about_blank());
   pickle->WriteBool(is_incognito_enabled());
 
+  PickleConsumerID(pickle, consumer_id_);
   PickleGlobs(pickle, globs_);
   PickleGlobs(pickle, exclude_globs_);
   PickleURLPatternSet(pickle, url_set_);
   PickleURLPatternSet(pickle, exclude_url_set_);
   PickleScripts(pickle, js_scripts_);
   PickleScripts(pickle, css_scripts_);
 }
 
 void UserScript::PickleGlobs(::Pickle* pickle,
                              const std::vector<std::string>& globs) const {
   pickle->WriteSizeT(globs.size());
   for (std::vector<std::string>::const_iterator glob = globs.begin();
        glob != globs.end(); ++glob) {
     pickle->WriteString(*glob);
   }
 }
 
+void UserScript::PickleConsumerID(::Pickle* pickle,
+                                  linked_ptr<ConsumerID> consumer_id) const {
+  pickle->WriteInt(consumer_id->host_type());
+  pickle->WriteString(consumer_id->host_id());
+  pickle->WriteInt(consumer_id->instance_type());
+  pickle->WriteInt(consumer_id->instance_id());
+}
+
 void UserScript::PickleURLPatternSet(::Pickle* pickle,
                                      const URLPatternSet& pattern_list) const {
   pickle->WriteSizeT(pattern_list.patterns().size());
   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(::Pickle* pickle,
                                const FileList& scripts) const {
   pickle->WriteSizeT(scripts.size());
   for (FileList::const_iterator file = scripts.begin();
        file != scripts.end(); ++file) {
     file->Pickle(pickle);
   }
 }
 
 void UserScript::Unpickle(const ::Pickle& pickle, 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);
 
-  CHECK(iter->ReadString(&extension_id_));
   CHECK(iter->ReadInt(&user_script_id_));
   CHECK(iter->ReadBool(&emulate_greasemonkey_));
   CHECK(iter->ReadBool(&match_all_frames_));
   CHECK(iter->ReadBool(&match_about_blank_));
   CHECK(iter->ReadBool(&incognito_enabled_));
 
+  consumer_id_.reset(UnpickleConsumerID(pickle, iter).release());
   UnpickleGlobs(pickle, iter, &globs_);
   UnpickleGlobs(pickle, iter, &exclude_globs_);
   UnpickleURLPatternSet(pickle, iter, &url_set_);
   UnpickleURLPatternSet(pickle, iter, &exclude_url_set_);
   UnpickleScripts(pickle, iter, &js_scripts_);
   UnpickleScripts(pickle, iter, &css_scripts_);
 }
 
 void UserScript::UnpickleGlobs(const ::Pickle& pickle, PickleIterator* iter,
                                std::vector<std::string>* globs) {
   size_t num_globs = 0;
   CHECK(iter->ReadSizeT(&num_globs));
   globs->clear();
   for (size_t i = 0; i < num_globs; ++i) {
     std::string glob;
     CHECK(iter->ReadString(&glob));
     globs->push_back(glob);
   }
 }
 
+linked_ptr<ConsumerID> UserScript::UnpickleConsumerID(const ::Pickle& pickle,
+                                                      PickleIterator* iter) {
+  int host_type;
+  std::string host_id;
+  int instance_type;
+  int instance_id;
+  CHECK(iter->ReadInt(&host_type));
+  CHECK(iter->ReadString(&host_id));
+  CHECK(iter->ReadInt(&instance_type));
+  CHECK(iter->ReadInt(&instance_id));
+  return make_linked_ptr(
+      new ConsumerID(static_cast<ConsumerID::HostType>(host_type), host_id,
+                     static_cast<ConsumerID::InstanceType>(instance_type),
+                     instance_id));
+}
+
 void UserScript::UnpickleURLPatternSet(const ::Pickle& pickle,
                                        PickleIterator* iter,
                                        URLPatternSet* pattern_list) {
   size_t num_patterns = 0;
   CHECK(iter->ReadSizeT(&num_patterns));
 
   pattern_list->ClearPatterns();
   for (size_t i = 0; i < num_patterns; ++i) {
     int valid_schemes;
     CHECK(iter->ReadInt(&valid_schemes));
@@ skipping 24 matching lines @@
 }
 
 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