Atomic UserScript ID generation

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"
 #include "extensions/common/switches.h"
 
 namespace {
 
+// This cannot be a plain int or int64 because we need to generate unique IDs
+// from multiple threads.
+base::StaticAtomicSequenceNumber g_user_script_id_generator;
+
 bool UrlMatchesGlobs(const std::vector<std::string>* globs,
                      const GURL& url) {
   for (std::vector<std::string>::const_iterator glob = globs->begin();
        glob != globs->end(); ++glob) {
     if (MatchPattern(url.spec(), *glob))
       return true;
   }
 
   return false;
 }
 
 }  // namespace
 
 namespace extensions {
 
 // The bitmask for valid user script injectable schemes used by URLPattern.
 enum {
   kValidUserScriptSchemes = URLPattern::SCHEME_CHROMEUI |
                             URLPattern::SCHEME_HTTP |
                             URLPattern::SCHEME_HTTPS |
                             URLPattern::SCHEME_FILE |
                             URLPattern::SCHEME_FTP
 };
 
 // static
 const char UserScript::kFileExtension[] = ".user.js";
 
+
+// static
+int UserScript::GenerateUserScriptID() {
+   return g_user_script_id_generator.GetNext();
+}
+
 bool UserScript::IsURLUserScript(const GURL& url,
                                  const std::string& mime_type) {
   return EndsWith(url.ExtractFileName(), kFileExtension, false) &&
       mime_type != "text/html";
 }
 
 // static
 int UserScript::ValidUserScriptSchemes(bool canExecuteScriptEverywhere) {
   if (canExecuteScriptEverywhere)
     return URLPattern::SCHEME_ALL;
@@ skipping 70 matching lines @@
   // Read the url from the pickle.
   std::string url;
   CHECK(pickle.ReadString(iter, &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->WriteInt64(user_script_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());
 
   PickleGlobs(pickle, globs_);
   PickleGlobs(pickle, exclude_globs_);
   PickleURLPatternSet(pickle, url_set_);
   PickleURLPatternSet(pickle, exclude_url_set_);
   PickleScripts(pickle, js_scripts_);
@@ skipping 29 matching lines @@
 }
 
 void UserScript::Unpickle(const ::Pickle& pickle, PickleIterator* iter) {
   // Read the run location.
   int run_location = 0;
   CHECK(pickle.ReadInt(iter, &run_location));
   CHECK(run_location >= 0 && run_location < RUN_LOCATION_LAST);
   run_location_ = static_cast<RunLocation>(run_location);
 
   CHECK(pickle.ReadString(iter, &extension_id_));
-  CHECK(pickle.ReadInt64(iter, &user_script_id_));
+  CHECK(pickle.ReadInt(iter, &user_script_id_));
   CHECK(pickle.ReadBool(iter, &emulate_greasemonkey_));
   CHECK(pickle.ReadBool(iter, &match_all_frames_));
   CHECK(pickle.ReadBool(iter, &match_about_blank_));
   CHECK(pickle.ReadBool(iter, &incognito_enabled_));
 
   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_);
@@ skipping 49 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