Make it so that you can refresh and see changes in Greasemonkey...

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 148 matching lines @@
   widget_helper_ = new RenderWidgetHelper(host_id_);
 
   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_NEW_USER_SCRIPTS,
+      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_NEW_USER_SCRIPTS,
+      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 221 matching lines @@
         process_.set_handle(process);
       }
 
       watcher_.StartWatching(process_.handle(), this);
     }
   }
 
   // Now that the process is created, set it's backgrounding accordingly.
   SetBackgrounded(backgrounded_);
 
-  // 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();
-  }
-
-  InitVisitedLinks(target_process);
-  InitGreasemonkeyScripts(target_process);
+  InitVisitedLinks();
+  InitGreasemonkeyScripts();
 
   if (max_page_id_ != -1)
     channel_->Send(new ViewMsg_SetNextPageID(max_page_id_ + 1));
 
   return true;
 }
 
-void RenderProcessHost::InitVisitedLinks(HANDLE target_process) {
+HANDLE RenderProcessHost::GetRendererProcessHandle() {
+  HANDLE result = process_.handle();
+  if (!result) {
+    // Renderer process can be null if it's started with the --single-process
+    // flag.
+    result = GetCurrentProcess();
+  }
+  return result;
+}
+
+void RenderProcessHost::InitVisitedLinks() {
   VisitedLinkMaster* visitedlink_master = profile_->GetVisitedLinkMaster();
   if (!visitedlink_master) {
     return;
   }
 
   SharedMemoryHandle handle_for_process = NULL;
-  visitedlink_master->ShareToProcess(target_process, &handle_for_process);
+  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(HANDLE target_process) {
+void RenderProcessHost::InitGreasemonkeyScripts() {
   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 = profile_->GetGreasemonkeyMaster();
   if (!greasemonkey_master) {
     return;
   }
 
   if (!greasemonkey_master->ScriptsReady()) {
     // No scripts ready.  :(
     return;
   }
 
+  // Update the renderer process with the current scripts.
+  SendGreasemonkeyScriptsUpdate(greasemonkey_master->GetSharedMemory());
+}
+
+void RenderProcessHost::SendGreasemonkeyScriptsUpdate(
+    SharedMemory *shared_memory) {
   SharedMemoryHandle handle_for_process = NULL;
-  greasemonkey_master->ShareToProcess(target_process, &handle_for_process);
+  shared_memory->ShareToProcess(GetRendererProcessHandle(),
+                                &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);
 }
@@ skipping 301 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_NEW_USER_SCRIPTS: {
+      SharedMemory* shared_memory = Details<SharedMemory>(details).ptr();
+      DCHECK(shared_memory);
+      if (shared_memory) {
+        SendGreasemonkeyScriptsUpdate(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());
 }