Add the ability for objects which derive from RefCountedThreadSafe to specify...

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/file_util.h"
 #include "base/histogram.h"
 #include "base/process_util.h"
 #include "base/thread.h"
 #include "chrome/browser/browser_about_handler.h"
 #include "chrome/browser/child_process_security_policy.h"
 #include "chrome/browser/chrome_plugin_browsing_context.h"
-#include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/extensions/extension_message_service.h"
 #include "chrome/browser/in_process_webkit/dom_storage_dispatcher_host.h"
 #include "chrome/browser/nacl_process_host.h"
 #include "chrome/browser/net/chrome_url_request_context.h"
 #include "chrome/browser/net/dns_global.h"
 #include "chrome/browser/notifications/desktop_notification_service.h"
 #include "chrome/browser/notifications/notifications_prefs_cache.h"
 #include "chrome/browser/plugin_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/privacy_blacklist/blacklist.h"
 #include "chrome/browser/privacy_blacklist/blacklist_observer.h"
 #include "chrome/browser/renderer_host/audio_renderer_host.h"
 #include "chrome/browser/renderer_host/browser_render_process_host.h"
 #include "chrome/browser/renderer_host/database_dispatcher_host.h"
-#include "chrome/browser/renderer_host/file_system_accessor.h"
 #include "chrome/browser/renderer_host/render_widget_helper.h"
 #include "chrome/browser/renderer_host/socket_stream_dispatcher_host.h"
 #include "chrome/browser/spellchecker.h"
 #include "chrome/browser/spellchecker_platform_engine.h"
 #include "chrome/browser/task_manager.h"
 #include "chrome/browser/worker_host/message_port_dispatcher.h"
 #include "chrome/browser/worker_host/worker_service.h"
 #include "chrome/common/appcache/appcache_dispatcher_host.h"
 #include "chrome/common/chrome_plugin_lib.h"
 #include "chrome/common/chrome_plugin_util.h"
@@ skipping 358 matching lines @@
     IPC_END_MESSAGE_MAP_EX()
   }
 
   if (!msg_is_ok) {
     BrowserRenderProcessHost::BadMessageTerminateProcess(msg.type(), handle());
   }
 
   return handled;
 }
 
+void ResourceMessageFilter::OnDestruct() {
+  ChromeThread::DeleteOnIOThread::Destruct(this);
+}
+
 void ResourceMessageFilter::OnReceiveContextMenuMsg(const IPC::Message& msg) {
   void* iter = NULL;
   ContextMenuParams params;
   if (!IPC::ParamTraits<ContextMenuParams>::Read(&msg, &iter, &params))
     return;
 
   // Fill in the dictionary suggestions if required.
   if (!params.misspelled_word.empty() &&
       spellchecker_ != NULL && params.spellcheck_enabled) {
     int misspell_location, misspell_length;
@@ skipping 171 matching lines @@
   }
 
   fonts[font_index] = font_handle;
   hdcs[font_index] = hdc;
   font_index = (font_index + 1) % kFontCacheSize;
 }
 #endif
 
 void ResourceMessageFilter::OnGetPlugins(bool refresh,
                                          IPC::Message* reply_msg) {
-  // Schedule plugin loading on the file thread.
-  // Note: it's possible that the only reference to this object is the task.  If
-  // If the task executes on the file thread, and before it returns, the task it
-  // posts to the IO thread runs, then this object will get destructed on the
-  // file thread.  We need this object to be destructed on the IO thread, so do
-  // the refcounting manually.
-  AddRef();
   ChromeThread::PostTask(
       ChromeThread::FILE, FROM_HERE,
-      NewRunnableFunction(&ResourceMessageFilter::OnGetPluginsOnFileThread,
-          this, refresh, reply_msg));
+      NewRunnableMethod(
+          this, &ResourceMessageFilter::OnGetPluginsOnFileThread, refresh,
+          reply_msg));
 }
 
 void ResourceMessageFilter::OnGetPluginsOnFileThread(
-    ResourceMessageFilter* filter,
-    bool refresh,
-    IPC::Message* reply_msg) {
+    bool refresh, IPC::Message* reply_msg) {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
   std::vector<WebPluginInfo> plugins;
   NPAPI::PluginList::Singleton()->GetPlugins(refresh, &plugins);
   ViewHostMsg_GetPlugins::WriteReplyParams(reply_msg, plugins);
   ChromeThread::PostTask(
       ChromeThread::IO, FROM_HERE,
-      NewRunnableMethod(filter, &ResourceMessageFilter::OnPluginsLoaded,
-          reply_msg));
-}
-
-void ResourceMessageFilter::OnPluginsLoaded(IPC::Message* reply_msg) {
-  Send(reply_msg);
-  Release();
+      NewRunnableMethod(this, &ResourceMessageFilter::Send, reply_msg));
 }
 
 void ResourceMessageFilter::OnGetPluginPath(const GURL& url,
                                             const GURL& policy_url,
                                             const std::string& mime_type,
                                             FilePath* filename,
                                             std::string* url_mime_type) {
   *filename = plugin_service_->GetPluginPath(
       url, policy_url, mime_type, url_mime_type);
 }
@@ skipping 485 matching lines @@
     return;
 
   net::HttpCache::Mode mode = enabled ?
       net::HttpCache::NORMAL : net::HttpCache::DISABLE;
   request_context_->GetURLRequestContext()->
       http_transaction_factory()->GetCache()->set_mode(mode);
 }
 
 void ResourceMessageFilter::OnGetFileSize(const FilePath& path,
                                           IPC::Message* reply_msg) {
-  // Increase the ref count to ensure ResourceMessageFilter won't be destroyed
-  // before GetFileSize callback is done.
-  AddRef();
-
   // Get file size only when the child process has been granted permission to
   // upload the file.
-  if (ChildProcessSecurityPolicy::GetInstance()->CanUploadFile(id(), path)) {
-    FileSystemAccessor::RequestFileSize(
-        path,
-        reply_msg,
-        NewCallback(this, &ResourceMessageFilter::ReplyGetFileSize));
-  } else {
-    ReplyGetFileSize(-1, reply_msg);
+  if (!ChildProcessSecurityPolicy::GetInstance()->CanUploadFile(id(), path)) {
+    ViewHostMsg_GetFileSize::WriteReplyParams(
+        reply_msg, static_cast<int64>(-1));
+    Send(reply_msg);
+    return;
   }
+
+  // Getting file size could take long time if it lives on a network share,
+  // so run it on FILE thread.
+  ChromeThread::PostTask(
+      ChromeThread::FILE, FROM_HERE,
+      NewRunnableMethod(
+          this, &ResourceMessageFilter::OnGetFileSizeOnFileThread, path,
+          reply_msg));
 }
 
-void ResourceMessageFilter::ReplyGetFileSize(int64 result, void* param) {
-  IPC::Message* reply_msg = static_cast<IPC::Message*>(param);
+void ResourceMessageFilter::OnGetFileSizeOnFileThread(
+    const FilePath& path, IPC::Message* reply_msg) {
+  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
+
+  int64 result;
+  if (!file_util::GetFileSize(path, &result))
+    result = -1;
   ViewHostMsg_GetFileSize::WriteReplyParams(reply_msg, result);
-  Send(reply_msg);
 
-  // Getting file size callback done, decrease the ref count.
-  Release();
+  ChromeThread::PostTask(
+      ChromeThread::IO, FROM_HERE,
+      NewRunnableMethod(this, &ResourceMessageFilter::Send, reply_msg));
 }
 
 void ResourceMessageFilter::OnKeygen(uint32 key_size_index,
                                      const std::string& challenge_string,
                                      const GURL& url,
                                      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,
       NewRunnableFunction(AboutTcmallocRendererCallback, pid, output));
 }
 #endif