Allow synchronous messages to be sent from threads other than the main thread...

chrome/browser/renderer_host/database_dispatcher_host.cc

 // Copyright (c) 2010 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/database_dispatcher_host.h"
 
 #if defined(OS_POSIX)
 #include "base/file_descriptor_posix.h"
 #endif
 
@@ skipping 72 matching lines @@
 
   db_tracker_->RemoveObserver(this);
 }
 
 bool DatabaseDispatcherHost::OnMessageReceived(
     const IPC::Message& message, bool* message_was_ok) {
   DCHECK(!shutdown_);
   *message_was_ok = true;
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP_EX(DatabaseDispatcherHost, message, *message_was_ok)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_DatabaseOpenFile, OnDatabaseOpenFile)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_DatabaseDeleteFile, OnDatabaseDeleteFile)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_DatabaseGetFileAttributes,
-                        OnDatabaseGetFileAttributes)
-    IPC_MESSAGE_HANDLER(ViewHostMsg_DatabaseGetFileSize,
-                        OnDatabaseGetFileSize)
+    IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_DatabaseOpenFile,
+                                    OnDatabaseOpenFile)
+    IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_DatabaseDeleteFile,
+                                    OnDatabaseDeleteFile)
+    IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_DatabaseGetFileAttributes,
+                                    OnDatabaseGetFileAttributes)
+    IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_DatabaseGetFileSize,
+                                    OnDatabaseGetFileSize)
     IPC_MESSAGE_HANDLER(ViewHostMsg_DatabaseOpened, OnDatabaseOpened)
     IPC_MESSAGE_HANDLER(ViewHostMsg_DatabaseModified, OnDatabaseModified)
     IPC_MESSAGE_HANDLER(ViewHostMsg_DatabaseClosed, OnDatabaseClosed)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(ViewHostMsg_AllowDatabase, OnAllowDatabase)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
   return handled;
 }
 
 void DatabaseDispatcherHost::ReceivedBadMessage(uint32 msg_type) {
@@ skipping 13 matching lines @@
   }
 
   if (!shutdown_ && message_sender_)
     message_sender_->Send(message);
   else
     delete message;
 }
 
 void DatabaseDispatcherHost::OnDatabaseOpenFile(const string16& vfs_file_name,
                                                 int desired_flags,
-                                                int32 message_id) {
+                                                IPC::Message* reply_msg) {
   if (!observer_added_) {
     observer_added_ = true;
     ChromeThread::PostTask(
         ChromeThread::FILE, FROM_HERE,
         NewRunnableMethod(this, &DatabaseDispatcherHost::AddObserver));
   }
 
   ChromeThread::PostTask(
       ChromeThread::FILE, FROM_HERE,
       NewRunnableMethod(this,
                         &DatabaseDispatcherHost::DatabaseOpenFile,
                         vfs_file_name,
                         desired_flags,
-                        message_id));
-}
-
-static void SetOpenFileResponseParams(
-    ViewMsg_DatabaseOpenFileResponse_Params* params,
-    base::PlatformFile file_handle,
-    base::PlatformFile dir_handle) {
-#if defined(OS_WIN)
-  params->file_handle = file_handle;
-#elif defined(OS_POSIX)
-  params->file_handle = base::FileDescriptor(file_handle, true);
-  params->dir_handle = base::FileDescriptor(dir_handle, true);
-#endif
+                        reply_msg));
 }
 
 // Scheduled by the IO thread on the file thread.
 // Opens the given database file, then schedules
 // a task on the IO thread's message loop to send an IPC back to
 // corresponding renderer process with the file handle.
 void DatabaseDispatcherHost::DatabaseOpenFile(const string16& vfs_file_name,
                                               int desired_flags,
-                                              int32 message_id) {
+                                              IPC::Message* reply_msg) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
   base::PlatformFile target_handle = base::kInvalidPlatformFileValue;
   base::PlatformFile target_dir_handle = base::kInvalidPlatformFileValue;
   string16 origin_identifier;
   string16 database_name;
   if (vfs_file_name.empty()) {
     VfsBackend::OpenTempFileInDirectory(db_tracker_->DatabaseDirectory(),
                                         desired_flags, process_handle_,
                                         &target_handle, &target_dir_handle);
   } else if (DatabaseUtil::CrackVfsFileName(vfs_file_name, &origin_identifier,
                                             &database_name, NULL) &&
              !db_tracker_->IsDatabaseScheduledForDeletion(origin_identifier,
                                                           database_name)) {
       FilePath db_file =
           DatabaseUtil::GetFullFilePathForVfsFile(db_tracker_, vfs_file_name);
       if (!db_file.empty()) {
         VfsBackend::OpenFile(db_file, desired_flags, process_handle_,
                              &target_handle, &target_dir_handle);
       }
   }
 
-  ViewMsg_DatabaseOpenFileResponse_Params response_params;
-  SetOpenFileResponseParams(&response_params, target_handle, target_dir_handle);
-  Send(new ViewMsg_DatabaseOpenFileResponse(message_id, response_params));
+  ViewHostMsg_DatabaseOpenFile::WriteReplyParams(
+      reply_msg,
+#if defined(OS_WIN)
+      target_handle
+#elif defined(OS_POSIX)
+      base::FileDescriptor(target_handle, true),
+      base::FileDescriptor(target_dir_handle, true)
+#endif
+      );
+  Send(reply_msg);
 }
 
 void DatabaseDispatcherHost::OnDatabaseDeleteFile(const string16& vfs_file_name,
                                                   const bool& sync_dir,
-                                                  int32 message_id) {
+                                                  IPC::Message* reply_msg) {
   ChromeThread::PostTask(
       ChromeThread::FILE, FROM_HERE,
       NewRunnableMethod(this,
                         &DatabaseDispatcherHost::DatabaseDeleteFile,
                         vfs_file_name,
                         sync_dir,
-                        message_id,
+                        reply_msg,
                         kNumDeleteRetries));
 }
 
 // Scheduled by the IO thread on the file thread.
 // Deletes the given database file, then schedules
 // a task on the IO thread's message loop to send an IPC back to
 // corresponding renderer process with the error code.
 void DatabaseDispatcherHost::DatabaseDeleteFile(const string16& vfs_file_name,
                                                 bool sync_dir,
-                                                int32 message_id,
+                                                IPC::Message* reply_msg,
                                                 int reschedule_count) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
 
   // Return an error if the file name is invalid or if the file could not
   // be deleted after kNumDeleteRetries attempts.
   int error_code = SQLITE_IOERR_DELETE;
   FilePath db_file =
       DatabaseUtil::GetFullFilePathForVfsFile(db_tracker_, vfs_file_name);
   if (!db_file.empty()) {
     error_code = VfsBackend::DeleteFile(db_file, sync_dir);
     if ((error_code == SQLITE_IOERR_DELETE) && reschedule_count) {
       // If the file could not be deleted, try again.
       ChromeThread::PostDelayedTask(
           ChromeThread::FILE, FROM_HERE,
           NewRunnableMethod(this,
                             &DatabaseDispatcherHost::DatabaseDeleteFile,
                             vfs_file_name,
                             sync_dir,
-                            message_id,
+                            reply_msg,
                             reschedule_count - 1),
           kDelayDeleteRetryMs);
       return;
     }
   }
 
-  Send(new ViewMsg_DatabaseDeleteFileResponse(message_id, error_code));
+  ViewHostMsg_DatabaseDeleteFile::WriteReplyParams(reply_msg, error_code);
+  Send(reply_msg);
 }
 
 void DatabaseDispatcherHost::OnDatabaseGetFileAttributes(
     const string16& vfs_file_name,
-    int32 message_id) {
+    IPC::Message* reply_msg) {
   ChromeThread::PostTask(
       ChromeThread::FILE, FROM_HERE,
       NewRunnableMethod(this,
                         &DatabaseDispatcherHost::DatabaseGetFileAttributes,
                         vfs_file_name,
-                        message_id));
+                        reply_msg));
 }
 
 // Scheduled by the IO thread on the file thread.
 // Gets the attributes of the given database file, then schedules
 // a task on the IO thread's message loop to send an IPC back to
 // corresponding renderer process.
 void DatabaseDispatcherHost::DatabaseGetFileAttributes(
     const string16& vfs_file_name,
-    int32 message_id) {
+    IPC::Message* reply_msg) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
   int32 attributes = -1;
   FilePath db_file =
       DatabaseUtil::GetFullFilePathForVfsFile(db_tracker_, vfs_file_name);
   if (!db_file.empty())
     attributes = VfsBackend::GetFileAttributes(db_file);
-  Send(new ViewMsg_DatabaseGetFileAttributesResponse(message_id, attributes));
+
+  ViewHostMsg_DatabaseGetFileAttributes::WriteReplyParams(
+      reply_msg, attributes);
+  Send(reply_msg);
 }
 
 void DatabaseDispatcherHost::OnDatabaseGetFileSize(
-  const string16& vfs_file_name, int32 message_id) {
+  const string16& vfs_file_name, IPC::Message* reply_msg) {
   ChromeThread::PostTask(
       ChromeThread::FILE, FROM_HERE,
       NewRunnableMethod(this,
                         &DatabaseDispatcherHost::DatabaseGetFileSize,
                         vfs_file_name,
-                        message_id));
+                        reply_msg));
 }
 
 // Scheduled by the IO thread on the file thread.
 // Gets the size of the given file, then schedules a task
 // on the IO thread's message loop to send an IPC back to
 // the corresponding renderer process.
 void DatabaseDispatcherHost::DatabaseGetFileSize(const string16& vfs_file_name,
-                                                 int32 message_id) {
+                                                 IPC::Message* reply_msg) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
   int64 size = 0;
   FilePath db_file =
       DatabaseUtil::GetFullFilePathForVfsFile(db_tracker_, vfs_file_name);
   if (!db_file.empty())
     size = VfsBackend::GetFileSize(db_file);
-  Send(new ViewMsg_DatabaseGetFileSizeResponse(message_id, size));
+
+  ViewHostMsg_DatabaseGetFileSize::WriteReplyParams(reply_msg, size);
+  Send(reply_msg);
 }
 
 void DatabaseDispatcherHost::OnDatabaseOpened(const string16& origin_identifier,
                                               const string16& database_name,
                                               const string16& description,
                                               int64 estimated_size) {
   ChromeThread::PostTask(
       ChromeThread::FILE, FROM_HERE,
       NewRunnableMethod(this,
                         &DatabaseDispatcherHost::DatabaseOpened,
@@ skipping 115 matching lines @@
                                         database_size, space_available));
   }
 }
 
 void DatabaseDispatcherHost::OnDatabaseScheduledForDeletion(
     const string16& origin_identifier,
     const string16& database_name) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
   Send(new ViewMsg_DatabaseCloseImmediately(origin_identifier, database_name));
 }