Initial Greasemonkey support

chrome/renderer/render_thread.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.
 
 #include <windows.h>
 #include <algorithm>
 
 #include "chrome/renderer/render_thread.h"
 
 #include "base/lazy_instance.h"
 #include "base/shared_memory.h"
 #include "base/thread_local.h"
 #include "chrome/common/chrome_plugin_lib.h"
 #include "chrome/common/ipc_logging.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/plugin/plugin_channel.h"
 #include "chrome/renderer/net/render_dns_master.h"
+#include "chrome/renderer/greasemonkey_slave.h"
 #include "chrome/renderer/render_process.h"
 #include "chrome/renderer/render_view.h"
 #include "chrome/renderer/visitedlink_slave.h"
 #include "webkit/glue/cache_manager.h"
 
 static const unsigned int kCacheStatsDelayMS = 2000 /* milliseconds */;
 
 // V8 needs a 1MB stack size.
 static const size_t kStackSize = 1024 * 1024;
 
 static base::LazyInstance<base::ThreadLocalPointer<RenderThread> >
     lazy_tls_ptr(base::LINKER_INITIALIZED);
 
 //-----------------------------------------------------------------------------
 // Methods below are only called on the owner's thread:
 
 // static
 RenderThread* RenderThread::current() {
   return lazy_tls_ptr.Pointer()->Get();
 }
 
 RenderThread::RenderThread(const std::wstring& channel_name)
     : Thread("Chrome_RenderThread"),
       channel_name_(channel_name),
       owner_loop_(MessageLoop::current()),
       visited_link_slave_(NULL),
+      greasemonkey_slave_(NULL),
       render_dns_master_(NULL),
       in_send_(0) {
   DCHECK(owner_loop_);
   base::Thread::Options options;
   options.stack_size = kStackSize;
   // When we run plugins in process, we actually run them on the render thread,
   // which means that we need to make the render thread pump UI events.
   if (RenderProcess::ShouldLoadPluginsInProcess())
     options.message_loop_type = MessageLoop::TYPE_UI;
   StartWithOptions(options);
@@ skipping 50 matching lines @@
 
   channel_.reset(new IPC::SyncChannel(channel_name_,
       IPC::Channel::MODE_CLIENT, this, NULL, owner_loop_, true,
       RenderProcess::GetShutDownEvent()));
 
   lazy_tls_ptr.Pointer()->Set(this);
 
   // The renderer thread should wind-up COM.
   CoInitialize(0);
 
-  // TODO(darin): We should actually try to share this object between
-  // RenderThread instances.
   visited_link_slave_ = new VisitedLinkSlave();
+  greasemonkey_slave_ = new GreasemonkeySlave();
 
   render_dns_master_.reset(new RenderDnsMaster());
 
 #ifdef IPC_MESSAGE_LOG_ENABLED
   IPC::Logging::current()->SetIPCSender(this);
 #endif
 }
 
 void RenderThread::CleanUp() {
   DCHECK(current() == this);
 
   // Need to destruct the SyncChannel to the browser before we go away because
   // it caches a pointer to this thread.
   channel_.reset();
 
   // Clean up plugin channels before this thread goes away.
   PluginChannelBase::CleanupChannels();
 
 #ifdef IPC_MESSAGE_LOG_ENABLED
   IPC::Logging::current()->SetIPCSender(NULL);
 #endif
 
   notification_service_.reset();
 
   delete visited_link_slave_;
   visited_link_slave_ = NULL;
 
+  delete greasemonkey_slave_;
+  greasemonkey_slave_ = NULL;
+
   CoUninitialize();
 }
 
 void RenderThread::OnUpdateVisitedLinks(SharedMemoryHandle table) {
   DCHECK(table) << "Bad table handle";
   visited_link_slave_->Init(table);
 }
 
+void RenderThread::OnUpdateGreasemonkeyScripts(SharedMemoryHandle scripts) {
+  DCHECK(scripts) << "Bad scripts handle";
+  greasemonkey_slave_->UpdateScripts(scripts);  
+}
+
 void RenderThread::OnMessageReceived(const IPC::Message& msg) {
   // NOTE: We could subclass router_ to intercept OnControlMessageReceived, but
   // it seems simpler to just process any control messages that we care about
   // up-front and then send the rest of the messages onto router_.
 
   if (msg.routing_id() == MSG_ROUTING_CONTROL) {
     IPC_BEGIN_MESSAGE_MAP(RenderThread, msg)
       IPC_MESSAGE_HANDLER(ViewMsg_VisitedLink_NewTable, OnUpdateVisitedLinks)
       IPC_MESSAGE_HANDLER(ViewMsg_SetNextPageID, OnSetNextPageID)
       IPC_MESSAGE_HANDLER(ViewMsg_New, OnCreateNewView)
       IPC_MESSAGE_HANDLER(ViewMsg_SetCacheCapacities, OnSetCacheCapacities)
       IPC_MESSAGE_HANDLER(ViewMsg_GetCacheResourceStats,
                           OnGetCacheResourceStats)
       IPC_MESSAGE_HANDLER(ViewMsg_PluginMessage, OnPluginMessage)
+      IPC_MESSAGE_HANDLER(ViewMsg_Greasemonkey_NewScripts,
+                          OnUpdateGreasemonkeyScripts)
       // send the rest to the router
       IPC_MESSAGE_UNHANDLED(router_.OnMessageReceived(msg))
     IPC_END_MESSAGE_MAP()
   } else {
     router_.OnMessageReceived(msg);
   }
 }
 
 void RenderThread::OnPluginMessage(const std::wstring& dll_path,
                                    const std::vector<uint8>& data) {
@@ skipping 45 matching lines @@
   // Rate limit informing the host of our cache stats.
   if (!cache_stats_factory_->empty())
     return;
 
   MessageLoop::current()->PostDelayedTask(FROM_HERE,
       cache_stats_factory_->NewRunnableMethod(
           &RenderThread::InformHostOfCacheStats),
       kCacheStatsDelayMS);
 }