Initial Greasemonkey support

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>
 #include <wininet.h>
 #include <algorithm>
 #include <sstream>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/debug_util.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/rand_util.h"
 #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/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 210 matching lines @@
     switches::kDebugPrint,
     switches::kAllowAllActiveX,
     switches::kMemoryProfiling,
     switches::kEnableWatchdog,
     switches::kMessageLoopHistogrammer,
     switches::kEnableDCHECK,
     switches::kSilentDumpOnDCHECK,
     switches::kDisablePopupBlocking,
     switches::kUseLowFragHeapCrt,
     switches::kGearsInRenderer,
+    switches::kEnableGreasemonkey,
   };
 
   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 135 matching lines @@
         process_.set_handle(process);
       }
 
       watcher_.StartWatching(process_.handle(), this);
     }
   }
 
   // Now that the process is created, set it's backgrounding accordingly.
   SetBackgrounded(backgrounded_);
 
-  VisitedLinkMaster* visitedlink_master = profile_->GetVisitedLinkMaster();
-  if (visitedlink_master) {
-    std::wstring history_table_name = visitedlink_master->GetSharedMemoryName();
-    SharedMemoryHandle handle_for_process = NULL;
-    HANDLE target_process = process_.handle();
-    if (!target_process) {
-      // Target process can be null if it's started with the --single-process
-      // flag.
-      target_process = GetCurrentProcess();
-    }
+  // Send the process its initial VisitedLink and Greasemonkey data.
+  HANDLE target_process = process_.handle();
+  if (!target_process) {
+    // Target process can be null if it's started with the --single-process
+    // flag.
+    target_process = GetCurrentProcess();
+  }
 
-    visitedlink_master->ShareToProcess(target_process, &handle_for_process);
-    DCHECK(handle_for_process);
-
-    channel_->Send(new ViewMsg_VisitedLink_NewTable(handle_for_process));
-  }
+  InitVisitedLinks(target_process);
+  InitGreasemonkeyScripts(target_process);
 
   if (max_page_id_ != -1)
     channel_->Send(new ViewMsg_SetNextPageID(max_page_id_ + 1));
 
   return true;
 }
 
+void RenderProcessHost::InitVisitedLinks(HANDLE target_process) {
+  VisitedLinkMaster* visitedlink_master = profile_->GetVisitedLinkMaster();
+  if (!visitedlink_master) return;
+
+  SharedMemoryHandle handle_for_process = NULL;
+  visitedlink_master->ShareToProcess(target_process, &handle_for_process);
+  DCHECK(handle_for_process);
+  if (handle_for_process) {
+    channel_->Send(new ViewMsg_VisitedLink_NewTable(handle_for_process));
+  }
+}
+
+void RenderProcessHost::InitGreasemonkeyScripts(HANDLE target_process) {
+  CommandLine command_line;
+  if (!command_line.HasSwitch(switches::kEnableGreasemonkey)) 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 =
+      Singleton<GreasemonkeyMaster>::get();
+  if (!greasemonkey_master) return;
+
+  // TODO(aa): This does blocking IO. Move to background thread.
+  greasemonkey_master->UpdateScripts();
+
+  SharedMemoryHandle handle_for_process = NULL;
+  greasemonkey_master->ShareToProcess(target_process, &handle_for_process);
+  DCHECK(handle_for_process);
+  if (handle_for_process) {
+    channel_->Send(new ViewMsg_Greasemonkey_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);
   listeners_.Remove(listener_id);
 
   // make sure that all associated resource requests are stopped.
@@ skipping 315 matching lines @@
   // 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());
 }