This is a rename of the term 'Greasemonkey' to 'user script' in Chromium.

chrome/renderer/greasemonkey_slave.cc

 // Copyright (c) 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/renderer/greasemonkey_slave.h"
+#include "chrome/renderer/user_script_slave.h"
 
 #include "base/logging.h"
 #include "base/pickle.h"
 #include "base/shared_memory.h"
 #include "googleurl/src/gurl.h"
 
 
-// GreasemonkeyScript
+// UserScript
 
-void GreasemonkeyScript::Parse(const StringPiece& script_text) {
+void UserScript::Parse(const StringPiece& script_text) {
   ParseMetadata(script_text);
 
   // TODO(aa): Set body to just the part after the metadata block? This would
   // significantly cut down on the size of the injected script in some cases.
   // Would require remembering the line number the body begins at, for correct
   // error line number reporting.
   body_ = script_text;
 }
 
-bool GreasemonkeyScript::MatchesUrl(const GURL& url) {
+bool UserScript::MatchesUrl(const GURL& url) {
   for (std::vector<std::string>::iterator pattern = include_patterns_.begin();
        pattern != include_patterns_.end(); ++pattern) {
     if (MatchPattern(url.spec(), *pattern)) {
       return true;
     }
   }
 
   return false;
 }
 
-void GreasemonkeyScript::ParseMetadata(const StringPiece& script_text) {
+void UserScript::ParseMetadata(const StringPiece& script_text) {
   // http://wiki.greasespot.net/Metadata_block
   StringPiece line;
   size_t line_start = 0;
   size_t line_end = 0;
   bool in_metadata = false;
 
   static const StringPiece kUserScriptBegin("// ==UserScript==");
   static const StringPiece kUserScriptEng("// ==/UserScript==");
   static const StringPiece kIncludeDeclaration("// @include ");
 
@@ skipping 24 matching lines @@
         AddInclude(pattern_trimmed);
       }
 
       // TODO(aa): Handle more types of metadata.
     }
 
     line_start = line_end + 1;
   }
 
   // If no @include patterns were specified, default to @include *.
-  // This is what Greasemonkey for Firefox does.
+  // This is what Greasemonkey does.
   if (include_patterns_.size() == 0) {
     AddInclude("*");
   }
 }
 
-void GreasemonkeyScript::AddInclude(const std::string &glob_pattern) {
+void UserScript::AddInclude(const std::string &glob_pattern) {
   include_patterns_.push_back(EscapeGlob(glob_pattern));
 }
 
-std::string GreasemonkeyScript::EscapeGlob(const std::string& input_pattern) {
+std::string UserScript::EscapeGlob(const std::string& input_pattern) {
   std::string output_pattern;
 
   for (size_t i = 0; i < input_pattern.length(); ++i) {
     switch (input_pattern[i]) {
       // These characters have special meaning to the MatchPattern() function,
       // so we escape them.
       case '\\':
       case '?':
         output_pattern += '\\';
         // fall through
 
       default:
         output_pattern += input_pattern[i];
     }
   }
 
   return output_pattern;
 }
 
 
-// GreasemonkeySlave
-GreasemonkeySlave::GreasemonkeySlave() : shared_memory_(NULL) {
+// UserScriptSlave
+UserScriptSlave::UserScriptSlave() : shared_memory_(NULL) {
 }
 
-bool GreasemonkeySlave::UpdateScripts(base::SharedMemoryHandle shared_memory) {
+bool UserScriptSlave::UpdateScripts(base::SharedMemoryHandle shared_memory) {
   scripts_.clear();
 
   // Create the shared memory object (read only).
   shared_memory_.reset(new base::SharedMemory(shared_memory, true));
   if (!shared_memory_.get())
     return false;
 
   // First get the size of the memory block.
   if (!shared_memory_->Map(sizeof(Pickle::Header)))
     return false;
@@ skipping 15 matching lines @@
 
   for (int i = 0; i < num_scripts; ++i) {
     const char* url = NULL;
     int url_length = 0;
     const char* body = NULL;
     int body_length = 0;
 
     pickle.ReadData(&iter, &url, &url_length);
     pickle.ReadData(&iter, &body, &body_length);
 
-    scripts_.push_back(GreasemonkeyScript(StringPiece(url, url_length)));
-    GreasemonkeyScript& script = scripts_.back();
+    scripts_.push_back(UserScript(StringPiece(url, url_length)));
+    UserScript& script = scripts_.back();
     script.Parse(StringPiece(body, body_length));
   }
 
   return true;
 }
 
-bool GreasemonkeySlave::InjectScripts(WebFrame* frame) {
-  for (std::vector<GreasemonkeyScript>::iterator script = scripts_.begin();
+bool UserScriptSlave::InjectScripts(WebFrame* frame) {
+  for (std::vector<UserScript>::iterator script = scripts_.begin();
        script != scripts_.end(); ++script) {
     if (script->MatchesUrl(frame->GetURL())) {
       frame->ExecuteJavaScript(script->GetBody().as_string(),
                                GURL(script->GetURL().as_string()));
     }
   }
 
   return true;
 }