TBR: Revert "Implement chromium.self in content scripts..."

chrome/browser/extensions/extension.cc

 // Copyright (c) 2006-2008 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/extension.h"
 
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "net/base/net_util.h"
@@ skipping 85 matching lines @@
       id_(rhs.id_),
       version_(new Version(*rhs.version_)),
       name_(rhs.name_),
       description_(rhs.description_),
       content_scripts_(rhs.content_scripts_),
       plugins_dir_(rhs.plugins_dir_),
       zip_hash_(rhs.zip_hash_),
       theme_paths_(rhs.theme_paths_) {
 }
 
+const GURL& Extension::url() {
+  if (!extension_url_.is_valid())
+    extension_url_ = GURL(std::string(chrome::kExtensionScheme) +
+                          chrome::kStandardSchemeSeparator + id_ + "/");
+
+  return extension_url_;
+}
+
+void Extension::set_id(const std::string& id) {
+  id_ = id;
+
+  // Reset url_ so that it gets reinitialized next time.
+  extension_url_ = GURL();
+}
+
 const std::string Extension::VersionString() const {
   return version_->GetString();
 }
 
 // static
 GURL Extension::GetResourceURL(const GURL& extension_url,
                                const std::string& relative_path) {
   DCHECK(extension_url.SchemeIs(chrome::kExtensionScheme));
   DCHECK(extension_url.path() == "/");
 
@@ skipping 197 matching lines @@
       // TODO(georged): Make GetResourceURL accept wstring too
       GURL url = GetResourceURL(WideToUTF8(relative));
       FilePath path = GetResourcePath(WideToUTF8(relative));
       result->css_scripts().push_back(UserScript::File(path, url));
     }
   }
 
   return true;
 }
 
-bool Extension::InitFromValue(const DictionaryValue& source, bool require_id,
+bool Extension::InitFromValue(const DictionaryValue& source,
                               std::string* error) {
-  // Initialize id.
+  // Initialize id. The ID is not required here because we don't require IDs for
+  // extensions used with --load-extension.
   if (source.HasKey(kIdKey)) {
     if (!source.GetString(kIdKey, &id_)) {
       *error = kInvalidIdError;
       return false;
     }
 
     // Normalize the string to lowercase, so it can be used as an URL component
     // (where GURL will lowercase it).
     StringToLowerASCII(&id_);
 
     // Verify that the id is legal.  The id is a hex string of the SHA-1 hash of
     // the public key.
     std::vector<uint8> id_bytes;
     if (!HexStringToBytes(id_, &id_bytes) || id_bytes.size() != kIdSize) {
       *error = kInvalidIdError;
       return false;
     }
-  } else if (require_id) {
-    *error = kInvalidIdError;
-    return false;
-  } else {
-    // Generate a random ID
-    static int counter = 0;
-    id_ = StringPrintf("%x", counter);
-    ++counter;
-
-    // pad the string out to 40 chars with zeroes.
-    id_.insert(0, 40 - id_.length(), '0');
   }
 
-  // Initialize the URL.
-  extension_url_ = GURL(std::string(chrome::kExtensionScheme) +
-                        chrome::kStandardSchemeSeparator + id_ + "/");
-
   // Initialize version.
   std::string version_str;
   if (!source.GetString(kVersionKey, &version_str)) {
     *error = kInvalidVersionError;
     return false;
   }
   version_.reset(Version::GetVersionFromString(version_str));
   if (!version_.get()) {
     *error = kInvalidVersionError;
     return false;
@@ skipping 79 matching lines @@
       DictionaryValue* content_script;
       if (!list_value->GetDictionary(i, &content_script)) {
         *error = FormatErrorMessage(kInvalidContentScriptError,
           IntToString(i));
         return false;
       }
 
       UserScript script;
       if (!LoadUserScriptHelper(content_script, i, error, &script))
         return false;  // Failed to parse script context definition
-      script.set_extension_id(id());
       content_scripts_.push_back(script);
     }
   }
 
   // Initialize the permissions (optional).
   if (source.HasKey(kPermissionsKey)) {
     ListValue* hosts = NULL;
     if (!source.GetList(kPermissionsKey, &hosts)) {
       *error = FormatErrorMessage(kInvalidPermissionsError, "");
       return false;
@@ skipping 26 matching lines @@
                                     IntToString(i));
         return false;
       }
 
       permissions_.push_back(pattern);
     }
   }
 
   return true;
 }