Third patch in getting rid of caching MessageLoop pointers and always using C...

chrome/browser/renderer_host/resource_message_filter.cc

 // Copyright (c) 2009 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/browser/renderer_host/resource_message_filter.h"
 
 #include "app/clipboard/clipboard.h"
 #include "app/gfx/native_widget_types.h"
 #include "base/command_line.h"
 #include "base/histogram.h"
@@ skipping 216 matching lines @@
   base::ProcessHandle peer_handle;
   if (!base::OpenProcessHandle(peer_pid, &peer_handle)) {
     NOTREACHED();
   }
   set_handle(peer_handle);
 
   // Hook AudioRendererHost to this object after channel is connected so it can
   // this object for sending messages.
   audio_renderer_host_->IPCChannelConnected(id(), handle(), this);
 
-  WorkerService::GetInstance()->Initialize(
-      resource_dispatcher_host_, ui_loop());
+  WorkerService::GetInstance()->Initialize(resource_dispatcher_host_);
   appcache_dispatcher_host_->Initialize(this, id(), handle());
   socket_stream_dispatcher_host_->Initialize(this, id());
   dom_storage_dispatcher_host_->Init(handle());
 }
 
 void ResourceMessageFilter::OnChannelError() {
   NotificationService::current()->Notify(
       NotificationType::RESOURCE_MESSAGE_FILTER_SHUTDOWN,
       Source<ResourceMessageFilter>(this),
       NotificationService::NoDetails());
@@ skipping 174 matching lines @@
         &misspell_location, &misspell_length,
         &params.dictionary_suggestions);
 
     // If not misspelled, make the misspelled_word param empty.
     if (!is_misspelled)
       params.misspelled_word.clear();
   }
 
   // Create a new ViewHostMsg_ContextMenu message.
   const ViewHostMsg_ContextMenu context_menu_message(msg.routing_id(), params);
-  ui_loop()->PostTask(FROM_HERE, new ContextMenuMessageDispatcher(
-      id(), context_menu_message));
+  ChromeThread::PostTask(
+      ChromeThread::UI, FROM_HERE,
+      new ContextMenuMessageDispatcher(id(), context_menu_message));
 }
 
 // Called on the IPC thread:
 bool ResourceMessageFilter::Send(IPC::Message* message) {
   if (!channel_) {
     delete message;
     return false;
   }
 
   return channel_->Send(message);
 }
 
 URLRequestContext* ResourceMessageFilter::GetRequestContext(
     uint32 request_id,
     const ViewHostMsg_Resource_Request& request_data) {
   URLRequestContextGetter* request_context = request_context_;
   // If the request has resource type of ResourceType::MEDIA, we use a request
   // context specific to media for handling it because these resources have
   // specific needs for caching.
   if (request_data.resource_type == ResourceType::MEDIA)
     request_context = media_request_context_;
   return request_context->GetURLRequestContext();
 }
 
-MessageLoop* ResourceMessageFilter::ui_loop() {
-  return render_widget_helper_->ui_loop();
-}
-
 void ResourceMessageFilter::OnMsgCreateWindow(
     int opener_id, bool user_gesture, int* route_id) {
   render_widget_helper_->CreateNewWindow(opener_id,
                                          user_gesture,
                                          handle(),
                                          route_id);
 }
 
 void ResourceMessageFilter::OnMsgCreateWidget(int opener_id,
                                               bool activatable,
@@ skipping 224 matching lines @@
 
 #if defined(OS_WIN)
   // We pass the renderer handle to assist the clipboard with using shared
   // memory objects. handle() is a handle to the process that would
   // own any shared memory that might be in the object list. We only do this
   // on Windows and it only applies to bitmaps. (On Linux, bitmaps
   // are copied pixel by pixel rather than using shared memory.)
   Clipboard::DuplicateRemoteHandles(handle(), long_living_objects);
 #endif
 
-  ui_loop()->PostTask(FROM_HERE, new WriteClipboardTask(long_living_objects));
+  ChromeThread::PostTask(
+      ChromeThread::UI, FROM_HERE, new WriteClipboardTask(long_living_objects));
 }
 
 #if !defined(OS_LINUX)
 // On non-Linux platforms, clipboard actions can be performed on the IO thread.
 // On Linux, since the clipboard is linked with GTK, we either have to do this
 // with GTK on the UI thread, or with Xlib on the BACKGROUND_X11 thread. In an
 // ideal world, we would do the latter. However, for now we're going to
 // terminate these calls on the UI thread. This risks deadlock in the case of
 // plugins, but it's better than crashing which is what doing on the IO thread
 // gives us.
@@ skipping 98 matching lines @@
   HISTOGRAM_COUNTS("WebCoreCache.CSSStylesheetsSizeKB",
                    static_cast<int>(stats.cssStyleSheets.size / 1024));
   HISTOGRAM_COUNTS("WebCoreCache.ScriptsSizeKB",
                    static_cast<int>(stats.scripts.size / 1024));
   HISTOGRAM_COUNTS("WebCoreCache.XSLStylesheetsSizeKB",
                    static_cast<int>(stats.xslStyleSheets.size / 1024));
   HISTOGRAM_COUNTS("WebCoreCache.FontsSizeKB",
                    static_cast<int>(stats.fonts.size / 1024));
   // We need to notify the TaskManager of these statistics from the UI
   // thread.
-  ui_loop()->PostTask(
-      FROM_HERE, NewRunnableFunction(
+  ChromeThread::PostTask(
+      ChromeThread::UI, FROM_HERE,
+      NewRunnableFunction(
           &ResourceMessageFilter::OnResourceTypeStatsOnUIThread,
           stats,
           base::GetProcId(handle())));
 }
 
 void ResourceMessageFilter::OnResourceTypeStatsOnUIThread(
     WebCache::ResourceTypeStats stats, base::ProcessId renderer_id) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   TaskManager::GetInstance()->model()->NotifyResourceTypeStats(
       renderer_id, stats);
@@ skipping 325 matching lines @@
                                      std::string* signed_public_key) {
   scoped_ptr<net::KeygenHandler> keygen_handler(
       new net::KeygenHandler(key_size_index,
                              challenge_string));
   *signed_public_key = keygen_handler->GenKeyAndSignChallenge();
 }
 
 #if defined(USE_TCMALLOC)
 void ResourceMessageFilter::OnRendererTcmalloc(base::ProcessId pid,
                                                const std::string& output) {
-  ui_loop()->PostTask(FROM_HERE,
+  ChromeThread::PostTask(
+      ChromeThread::UI, FROM_HERE,
       NewRunnableFunction(AboutTcmallocRendererCallback, pid, output));
 }
 #endif