Bug fix: produce unique temp file names when the VFS requests a handle to a n...

chrome/browser/renderer_host/database_dispatcher_host.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/database_dispatcher_host.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
@@ skipping 46 matching lines @@
 
   // Every time we get a DB-related message, we AddRef() the resource
   // message filterto make sure it doesn't get destroyed before we have
   // a chance to send the reply back. So we need to Release() is here
   // and allow it to be destroyed if needed.
   sender->Release();
 }
 
 // Make sure the flags used to open a DB file are consistent.
 static bool OpenFileFlagsAreConsistent(const OpenFileParams& params) {
-  if (params.file_name == params.db_dir) {
-    return (params.desired_flags == SQLITE_OPEN_READONLY);
+  // Is this a request for a temp file?
+  // We should be able to delete temp files when they're closed
+  // and create them as needed
+  if ((params.file_name == params.db_dir) &&
+      (!(params.desired_flags & SQLITE_OPEN_DELETEONCLOSE) ||
+       !(params.desired_flags & SQLITE_OPEN_CREATE))) {
+    return false;
   }
 
   const int file_type = params.desired_flags & 0x00007F00;
   const bool is_exclusive =
     (params.desired_flags & SQLITE_OPEN_EXCLUSIVE) != 0;
   const bool is_delete =
     (params.desired_flags & SQLITE_OPEN_DELETEONCLOSE) != 0;
   const bool is_create =
     (params.desired_flags & SQLITE_OPEN_CREATE) != 0;
   const bool is_read_only =
@@ skipping 80 matching lines @@
     if (params.desired_flags & SQLITE_OPEN_EXCLUSIVE) {
       flags |= base::PLATFORM_FILE_EXCLUSIVE_READ |
                base::PLATFORM_FILE_EXCLUSIVE_WRITE;
     }
 
     if (params.desired_flags & SQLITE_OPEN_DELETEONCLOSE) {
       flags |= base::PLATFORM_FILE_TEMPORARY | base::PLATFORM_FILE_HIDDEN |
                base::PLATFORM_FILE_DELETE_ON_CLOSE;
     }
 
+    // If this is a request for a handle to a temp file, get a unique file name
+    FilePath file_name;
+    if (params.file_name == params.db_dir) {
+      if (!file_util::CreateTemporaryFileInDir(params.db_dir, &file_name)) {
+        file_name = FilePath();
+      }
+    } else {
+      file_name = params.file_name;
+    }
+
     // Try to open/create the DB file.
     base::PlatformFile file_handle =
-      base::CreatePlatformFile(params.file_name.ToWStringHack(), flags, NULL);
+        (file_name.empty() ? base::kInvalidPlatformFileValue :
+         base::CreatePlatformFile(file_name.ToWStringHack(), flags, NULL));
     if (file_handle != base::kInvalidPlatformFileValue) {
 #if defined(OS_WIN)
       // Duplicate the file handle.
       if (!DuplicateHandle(GetCurrentProcess(), file_handle,
                            params.handle, &target_handle, 0, false,
                            DUPLICATE_CLOSE_SOURCE | DUPLICATE_SAME_ACCESS)) {
           // file_handle is closed whether or not DuplicateHandle succeeds.
           target_handle = INVALID_HANDLE_VALUE;
       }
 #elif defined(OS_POSIX)
@@ skipping 11 matching lines @@
             base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ, NULL);
         if (target_dir_handle == base::kInvalidPlatformFileValue) {
           base::ClosePlatformFile(target_handle);
           target_handle = base::kInvalidPlatformFileValue;
         }
       }
 #endif
     }
   }
 
-  ViewMsg_DatabaseOpenFileResponse_Params response_params =
+  ViewMsg_DatabaseOpenFileResponse_Params response_params;
 #if defined(OS_WIN)
-    { target_handle };
+  response_params.file_handle = target_handle;
 #elif defined(OS_POSIX)
-    { base::FileDescriptor(target_handle, true),
-      base::FileDescriptor(target_dir_handle, true) };
+  response_params.file_handle = base::FileDescriptor(target_handle, true);
+  response_params.dir_handle = base::FileDescriptor(target_dir_handle, true);
 #endif
 
    io_thread_message_loop->PostTask(FROM_HERE,
-     NewRunnableFunction(SendMessage, sender,
-       new ViewMsg_DatabaseOpenFileResponse(message_id, response_params)));
+       NewRunnableFunction(SendMessage, sender,
+           new ViewMsg_DatabaseOpenFileResponse(message_id, response_params)));
 }
 
 // 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.
 static void DatabaseDeleteFile(
     MessageLoop* io_thread_message_loop,
     const DeleteFileParams& params,
     int32 message_id,
     int reschedule_count,
     ResourceMessageFilter* sender) {
   // Return an error if the file could not be deleted
   // after kNumDeleteRetries times.
   if (!reschedule_count) {
     io_thread_message_loop->PostTask(FROM_HERE,
-      NewRunnableFunction(SendMessage, sender,
-        new ViewMsg_DatabaseDeleteFileResponse(
-          message_id, SQLITE_IOERR_DELETE)));
+        NewRunnableFunction(SendMessage, sender,
+            new ViewMsg_DatabaseDeleteFileResponse(
+                message_id, SQLITE_IOERR_DELETE)));
     return;
   }
 
   // If the file does not exist, we're done.
   if (!file_util::PathExists(params.file_name)) {
     io_thread_message_loop->PostTask(FROM_HERE,
-      NewRunnableFunction(SendMessage, sender,
-        new ViewMsg_DatabaseDeleteFileResponse(message_id, SQLITE_OK)));
+        NewRunnableFunction(SendMessage, sender,
+            new ViewMsg_DatabaseDeleteFileResponse(message_id, SQLITE_OK)));
     return;
   }
 
 
   // If the file could not be deleted, try again.
   if (!file_util::Delete(params.file_name, false)) {
     MessageLoop::current()->PostDelayedTask(FROM_HERE,
-      NewRunnableFunction(DatabaseDeleteFile, io_thread_message_loop,
-        params, message_id, reschedule_count - 1, sender),
+        NewRunnableFunction(DatabaseDeleteFile, io_thread_message_loop,
+            params, message_id, reschedule_count - 1, sender),
       kDelayDeleteRetryMs);
     return;
   }
 
   // File existed and it was successfully deleted
   int error_code = SQLITE_OK;
 #if defined(OS_POSIX)
   // sync the DB directory if needed
   if (params.sync_dir) {
     base::PlatformFile dir_fd = base::CreatePlatformFile(
       params.db_dir.ToWStringHack(), base::PLATFORM_FILE_READ, NULL);
     if (dir_fd == base::kInvalidPlatformFileValue) {
       error_code = SQLITE_CANTOPEN;
     } else {
       if (fsync(dir_fd)) {
         error_code = SQLITE_IOERR_DIR_FSYNC;
       }
       base::ClosePlatformFile(dir_fd);
     }
   }
 #endif
 
   io_thread_message_loop->PostTask(FROM_HERE,
-    NewRunnableFunction(SendMessage, sender,
-      new ViewMsg_DatabaseDeleteFileResponse(message_id, error_code)));
+      NewRunnableFunction(SendMessage, sender,
+          new ViewMsg_DatabaseDeleteFileResponse(message_id, error_code)));
 }
 
 // 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.
 static void DatabaseGetFileAttributes(
     MessageLoop* io_thread_message_loop,
     const FilePath& file_name,
     int32 message_id,
     ResourceMessageFilter* sender) {
 #if defined(OS_WIN)
   uint32 attributes = GetFileAttributes(file_name.value().c_str());
 #elif defined(OS_POSIX)
   uint32 attributes = 0;
   if (!access(file_name.value().c_str(), R_OK)) {
     attributes |= static_cast<uint32>(R_OK);
   }
   if (!access(file_name.value().c_str(), W_OK)) {
     attributes |= static_cast<uint32>(W_OK);
   }
   if (!attributes) {
     attributes = -1;
   }
 #endif
 
   io_thread_message_loop->PostTask(FROM_HERE,
-    NewRunnableFunction(SendMessage, sender,
-      new ViewMsg_DatabaseGetFileAttributesResponse(message_id, attributes)));
+      NewRunnableFunction(SendMessage, sender,
+          new ViewMsg_DatabaseGetFileAttributesResponse(
+              message_id, attributes)));
 }
 
 // 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.
 static void DatabaseGetFileSize(
     MessageLoop* io_thread_message_loop,
     const FilePath& file_name,
     int32 message_id,
     ResourceMessageFilter* sender) {
   int64 size = 0;
   if (!file_util::GetFileSize(file_name, &size)) {
     size = 0;
   }
 
   io_thread_message_loop->PostTask(FROM_HERE,
-    NewRunnableFunction(SendMessage, sender,
-      new ViewMsg_DatabaseGetFileSizeResponse(message_id, size)));
+      NewRunnableFunction(SendMessage, sender,
+          new ViewMsg_DatabaseGetFileSizeResponse(message_id, size)));
 }
 
 } // namespace
 
 DatabaseDispatcherHost::DatabaseDispatcherHost(
   const FilePath& profile_path,
   ResourceMessageFilter* resource_message_filter)
   : profile_path_(profile_path),
     resource_message_filter_(resource_message_filter),
     file_thread_message_loop_(
@@ skipping 48 matching lines @@
   }
   return GetDBDir().Append(file_name);
 }
 
 void DatabaseDispatcherHost::OnDatabaseOpenFile(
   const FilePath& file_name, int desired_flags,
   int32 message_id) {
   FilePath db_file_name = GetDBFileFullPath(file_name);
 
   if (db_file_name.empty()) {
-    ViewMsg_DatabaseOpenFileResponse_Params response_params =
+    ViewMsg_DatabaseOpenFileResponse_Params response_params;
 #if defined(OS_WIN)
-      { base::kInvalidPlatformFileValue };
+    response_params.file_handle = base::kInvalidPlatformFileValue;
 #elif defined(OS_POSIX)
-      { base::FileDescriptor(base::kInvalidPlatformFileValue, true),
-        base::FileDescriptor(base::kInvalidPlatformFileValue, true) };
+    response_params.file_handle =
+        base::FileDescriptor(base::kInvalidPlatformFileValue, true);
+    response_params.dir_handle =
+        base::FileDescriptor(base::kInvalidPlatformFileValue, true);
 #endif
     resource_message_filter_->Send(new ViewMsg_DatabaseOpenFileResponse(
-      message_id, response_params));
+        message_id, response_params));
     return;
   }
 
   OpenFileParams params = { GetDBDir(), db_file_name, desired_flags,
     resource_message_filter_->handle() };
   resource_message_filter_->AddRef();
   file_thread_message_loop_->PostTask(FROM_HERE,
-    NewRunnableFunction(DatabaseOpenFile, MessageLoop::current(),
-      params, message_id, resource_message_filter_));
+      NewRunnableFunction(DatabaseOpenFile, MessageLoop::current(),
+          params, message_id, resource_message_filter_));
 }
 
 void DatabaseDispatcherHost::OnDatabaseDeleteFile(
   const FilePath& file_name, const bool& sync_dir, int32 message_id) {
   FilePath db_file_name = GetDBFileFullPath(file_name);
   if (db_file_name.empty()) {
     resource_message_filter_->Send(new ViewMsg_DatabaseDeleteFileResponse(
-      message_id, SQLITE_IOERR_DELETE));
+        message_id, SQLITE_IOERR_DELETE));
     return;
   }
 
   DeleteFileParams params = { GetDBDir(), db_file_name, sync_dir };
   resource_message_filter_->AddRef();
   file_thread_message_loop_->PostTask(FROM_HERE,
-    NewRunnableFunction(DatabaseDeleteFile, MessageLoop::current(),
-      params, message_id, kNumDeleteRetries, resource_message_filter_));
+      NewRunnableFunction(DatabaseDeleteFile, MessageLoop::current(),
+          params, message_id, kNumDeleteRetries, resource_message_filter_));
 }
 
 void DatabaseDispatcherHost::OnDatabaseGetFileAttributes(
   const FilePath& file_name, int32 message_id) {
   FilePath db_file_name = GetDBFileFullPath(file_name);
   if (db_file_name.empty()) {
     resource_message_filter_->Send(
-      new ViewMsg_DatabaseGetFileAttributesResponse(
-        message_id, -1));
+        new ViewMsg_DatabaseGetFileAttributesResponse(
+            message_id, -1));
     return;
   }
 
   resource_message_filter_->AddRef();
   file_thread_message_loop_->PostTask(FROM_HERE,
-    NewRunnableFunction(DatabaseGetFileAttributes, MessageLoop::current(),
-      db_file_name, message_id, resource_message_filter_));
+      NewRunnableFunction(DatabaseGetFileAttributes, MessageLoop::current(),
+          db_file_name, message_id, resource_message_filter_));
 }
 
 void DatabaseDispatcherHost::OnDatabaseGetFileSize(
   const FilePath& file_name, int32 message_id) {
   FilePath db_file_name = GetDBFileFullPath(file_name);
   if (db_file_name.empty()) {
     resource_message_filter_->Send(new ViewMsg_DatabaseGetFileSizeResponse(
-      message_id, 0));
+        message_id, 0));
     return;
   }
 
   resource_message_filter_->AddRef();
   file_thread_message_loop_->PostTask(FROM_HERE,
-    NewRunnableFunction(DatabaseGetFileSize, MessageLoop::current(),
-      db_file_name, message_id, resource_message_filter_));
+      NewRunnableFunction(DatabaseGetFileSize, MessageLoop::current(),
+         db_file_name, message_id, resource_message_filter_));
 }