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

chrome/browser/render_process_host.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.
 
 // Represents the browser side of the browser <--> renderer communication
 // channel. There will be one RenderProcessHost per renderer process.
 
 #include "chrome/browser/render_process_host.h"
 
 #include <windows.h>
@@ skipping 12 matching lines @@
 #include "base/shared_memory.h"
 #include "base/singleton.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 #include "base/thread.h"
 #include "base/win_util.h"
 #include "chrome/app/result_codes.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/cache_manager_host.h"
+#include "chrome/browser/extensions/user_script_master.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/plugin_service.h"
 #include "chrome/browser/render_widget_helper.h"
 #include "chrome/browser/render_view_host.h"
 #include "chrome/browser/renderer_security_policy.h"
 #include "chrome/browser/resource_message_filter.h"
 #include "chrome/browser/sandbox_policy.h"
 #include "chrome/browser/spellchecker.h"
 #include "chrome/browser/visitedlink_master.h"
-#include "chrome/browser/greasemonkey_master.h"
 #include "chrome/browser/web_contents.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/debug_flags.h"
 #include "chrome/common/l10n_util.h"
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "chrome/common/process_watcher.h"
@@ skipping 107 matching lines @@
 
   CacheManagerHost::GetInstance()->Add(host_id_);
   RendererSecurityPolicy::GetInstance()->Add(host_id_);
 
   PrefService* prefs = profile->GetPrefs();
   prefs->AddPrefObserver(prefs::kBlockPopups, this);
   widget_helper_->set_block_popups(
       profile->GetPrefs()->GetBoolean(prefs::kBlockPopups));
 
   NotificationService::current()->AddObserver(this,
-      NOTIFY_GREASEMONKEY_SCRIPTS_LOADED,
-      NotificationService::AllSources());
+      NOTIFY_USER_SCRIPTS_LOADED, NotificationService::AllSources());
 
   // Note: When we create the RenderProcessHost, it's technically backgrounded,
   //       because it has no visible listeners.  But the process doesn't
   //       actually exist yet, so we'll Background it later, after creation.
 }
 
 RenderProcessHost::~RenderProcessHost() {
   // Some tests hold RenderProcessHost in a scoped_ptr, so we must call
   // Unregister here as well as in response to Release().
   Unregister();
 
   // We may have some unsent messages at this point, but that's OK.
   channel_.reset();
 
   if (process_.handle() && !run_renderer_in_process_) {
     watcher_.StopWatching();
     ProcessWatcher::EnsureProcessTerminated(process_.handle());
   }
 
   profile_->GetPrefs()->RemovePrefObserver(prefs::kBlockPopups, this);
 
   NotificationService::current()->RemoveObserver(this,
-      NOTIFY_GREASEMONKEY_SCRIPTS_LOADED,
-      NotificationService::AllSources());
+      NOTIFY_USER_SCRIPTS_LOADED, NotificationService::AllSources());
 }
 
 void RenderProcessHost::Unregister() {
   if (host_id_ >= 0) {
     CacheManagerHost::GetInstance()->Remove(host_id_);
     RendererSecurityPolicy::GetInstance()->Remove(host_id_);
     all_hosts.Remove(host_id_);
     host_id_ = -1;
   }
 }
@@ skipping 65 matching lines @@
     switches::kDebugPrint,
     switches::kAllowAllActiveX,
     switches::kMemoryProfiling,
     switches::kEnableWatchdog,
     switches::kMessageLoopHistogrammer,
     switches::kEnableDCHECK,
     switches::kSilentDumpOnDCHECK,
     switches::kDisablePopupBlocking,
     switches::kUseLowFragHeapCrt,
     switches::kGearsInRenderer,
-    switches::kEnableGreasemonkey,
+    switches::kEnableUserScripts,
     switches::kEnableVideo,
   };
 
   for (int i = 0; i < arraysize(switch_names); ++i) {
     if (browser_command_line.HasSwitch(switch_names[i])) {
       CommandLine::AppendSwitchWithValue(
           &cmd_line, switch_names[i],
           browser_command_line.GetSwitchValue(switch_names[i]));
     }
   }
@@ skipping 137 matching lines @@
       }
 
       watcher_.StartWatching(process_.handle(), this);
     }
   }
 
   // Now that the process is created, set it's backgrounding accordingly.
   SetBackgrounded(backgrounded_);
 
   InitVisitedLinks();
-  InitGreasemonkeyScripts();
+  InitUserScripts();
 
   if (max_page_id_ != -1)
     channel_->Send(new ViewMsg_SetNextPageID(max_page_id_ + 1));
 
   return true;
 }
 
 base::ProcessHandle RenderProcessHost::GetRendererProcessHandle() {
   if (run_renderer_in_process_)
     return base::Process::Current().handle();
   return process_.handle();
 }
 
 void RenderProcessHost::InitVisitedLinks() {
   VisitedLinkMaster* visitedlink_master = profile_->GetVisitedLinkMaster();
   if (!visitedlink_master) {
     return;
   }
 
   base::SharedMemoryHandle handle_for_process = NULL;
   visitedlink_master->ShareToProcess(GetRendererProcessHandle(),
                                      &handle_for_process);
   DCHECK(handle_for_process);
   if (handle_for_process) {
     channel_->Send(new ViewMsg_VisitedLink_NewTable(handle_for_process));
   }
 }
 
-void RenderProcessHost::InitGreasemonkeyScripts() {
+void RenderProcessHost::InitUserScripts() {
   CommandLine command_line;
-  if (!command_line.HasSwitch(switches::kEnableGreasemonkey)) {
+  if (!command_line.HasSwitch(switches::kEnableUserScripts)) {
     return;
   }
 
   // TODO(aa): Figure out lifetime and ownership of this object
   // - VisitedLinkMaster is owned by Profile, but there has been talk of
   //   having scripts live elsewhere besides the profile.
   // - File IO should be asynchronous (see VisitedLinkMaster), but how do we
   //   get scripts to the first renderer without blocking startup? Should we
   //   cache some information across restarts?
-  GreasemonkeyMaster* greasemonkey_master = profile_->GetGreasemonkeyMaster();
-  if (!greasemonkey_master) {
+  UserScriptMaster* user_script_master = profile_->GetUserScriptMaster();
+  if (!user_script_master) {
     return;
   }
 
-  if (!greasemonkey_master->ScriptsReady()) {
+  if (!user_script_master->ScriptsReady()) {
     // No scripts ready.  :(
     return;
   }
 
   // Update the renderer process with the current scripts.
-  SendGreasemonkeyScriptsUpdate(greasemonkey_master->GetSharedMemory());
+  SendUserScriptsUpdate(user_script_master->GetSharedMemory());
 }
 
-void RenderProcessHost::SendGreasemonkeyScriptsUpdate(
+void RenderProcessHost::SendUserScriptsUpdate(
     base::SharedMemory *shared_memory) {
   base::SharedMemoryHandle handle_for_process = NULL;
   shared_memory->ShareToProcess(GetRendererProcessHandle(),
                                 &handle_for_process);
   DCHECK(handle_for_process);
   if (handle_for_process) {
-    channel_->Send(new ViewMsg_Greasemonkey_NewScripts(handle_for_process));
+    channel_->Send(new ViewMsg_UserScripts_NewScripts(handle_for_process));
   }
 }
 
 void RenderProcessHost::Attach(IPC::Channel::Listener* listener,
                                int routing_id) {
   listeners_.AddWithID(listener, routing_id);
 }
 
 void RenderProcessHost::Release(int listener_id) {
   DCHECK(listeners_.Lookup(listener_id) != NULL);
@@ skipping 300 matching lines @@
       std::wstring* pref_name_in = Details<std::wstring>(details).ptr();
       DCHECK(Source<PrefService>(source).ptr() == profile()->GetPrefs());
       if (*pref_name_in == prefs::kBlockPopups) {
         widget_helper_->set_block_popups(
             profile()->GetPrefs()->GetBoolean(prefs::kBlockPopups));
       } else {
         NOTREACHED() << "unexpected pref change notification" << *pref_name_in;
       }
       break;
     }
-    case NOTIFY_GREASEMONKEY_SCRIPTS_LOADED: {
+    case NOTIFY_USER_SCRIPTS_LOADED: {
       base::SharedMemory* shared_memory =
           Details<base::SharedMemory>(details).ptr();
       DCHECK(shared_memory);
       if (shared_memory) {
-        SendGreasemonkeyScriptsUpdate(shared_memory);
+        SendUserScriptsUpdate(shared_memory);
       }
       break;
     }
     default: {
       NOTREACHED();
       break;
     }
   }
 }
 
 // static
 bool RenderProcessHost::ShouldTryToUseExistingProcessHost() {
   unsigned int renderer_process_count =
       static_cast<unsigned int>(all_hosts.size());
 
   // NOTE: Sometimes it's necessary to create more render processes than
   //       GetMaxRendererProcessCount(), for instance when we want to create
   //       a renderer process for a profile that has no existing renderers.
   //       This is OK in moderation, since the GetMaxRendererProcessCount()
   //       is conservative.
 
   return run_renderer_in_process() ||
          (renderer_process_count >= GetMaxRendererProcessCount());
 }