Change some snapshot- or temporary-file related changes to use ScopedFile

chrome/browser/sync_file_system/drive_file_sync_service.cc

 // Copyright (c) 2012 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/sync_file_system/drive_file_sync_service.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
@@ skipping 13 matching lines @@
 #include "chrome/browser/sync_file_system/conflict_resolution_policy.h"
 #include "chrome/browser/sync_file_system/drive_file_sync_client.h"
 #include "chrome/browser/sync_file_system/drive_file_sync_util.h"
 #include "chrome/browser/sync_file_system/drive_metadata_store.h"
 #include "chrome/browser/sync_file_system/file_status_observer.h"
 #include "chrome/browser/sync_file_system/remote_change_processor.h"
 #include "chrome/browser/sync_file_system/sync_file_system.pb.h"
 #include "chrome/common/extensions/extension.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/common/constants.h"
+#include "webkit/blob/scoped_file.h"
 #include "webkit/fileapi/file_system_url.h"
 #include "webkit/fileapi/syncable/sync_file_metadata.h"
 #include "webkit/fileapi/syncable/sync_file_type.h"
 #include "webkit/fileapi/syncable/syncable_file_system_util.h"
 
 using fileapi::FileSystemURL;
 
 namespace sync_file_system {
 
 namespace {
 
 const base::FilePath::CharType kTempDirName[] = FILE_PATH_LITERAL("tmp");
 const base::FilePath::CharType kSyncFileSystemDir[] =
     FILE_PATH_LITERAL("Sync FileSystem");
 
 // Incremental sync polling interval.
 // TODO(calvinlo): Improve polling algorithm dependent on whether push
 // notifications are on or off.
 const int64 kMinimumPollingDelaySeconds = 5;
 const int64 kMaximumPollingDelaySeconds = 10 * 60;  // 10 min
 const int64 kPollingDelaySecondsWithNotification = 4 * 60 * 60;  // 4 hr
 const double kDelayMultiplier = 1.6;
 
 bool CreateTemporaryFile(const base::FilePath& dir_path,
-                         base::FilePath* temp_file) {
-  return file_util::CreateDirectory(dir_path) &&
-      file_util::CreateTemporaryFileInDir(dir_path, temp_file);
-}
-
-void DeleteTemporaryFile(const base::FilePath& file_path) {
-  if (!content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE)) {
-    content::BrowserThread::PostTask(
-        content::BrowserThread::FILE, FROM_HERE,
-        base::Bind(&DeleteTemporaryFile, file_path));
-    return;
-  }
-
-  if (!file_util::Delete(file_path, true))
-    LOG(ERROR) << "Leaked temporary file for Sync FileSystem: "
-               << file_path.value();
+                         webkit_blob::ScopedFile* temp_file) {
+  base::FilePath temp_file_path;
+  const bool success = file_util::CreateDirectory(dir_path) &&
+      file_util::CreateTemporaryFileInDir(dir_path, &temp_file_path);
+  if (!success)
+    return success;
+  *temp_file = webkit_blob::ScopedFile(
+      temp_file_path,
+      webkit_blob::ScopedFile::DELETE_ON_SCOPE_OUT,
+      BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE));

[tzik, 2013/04/25 05:06:07]

Since this function should be called on IO-allowed thread, can it be
MessageLoopProxy::current()?

[kinuko, 2013/04/25 06:02:08]

Done.

+  return success;
 }
 
 void EmptyStatusCallback(SyncStatusCode status) {}
 
 void DidHandleUnregisteredOrigin(const GURL& origin, SyncStatusCode status) {
   // TODO(calvinlo): Disable syncing if status not ok (http://crbug.com/171611).
   DCHECK_EQ(SYNC_STATUS_OK, status);
   if (status != SYNC_STATUS_OK) {
     LOG(WARNING) << "Remove origin failed for: " << origin.spec()
                  << " status=" << status;
@@ skipping 68 matching lines @@
 };
 
 struct DriveFileSyncService::ProcessRemoteChangeParam {
   scoped_ptr<TaskToken> token;
   RemoteChange remote_change;
   SyncFileCallback callback;
 
   DriveMetadata drive_metadata;
   SyncFileMetadata local_metadata;
   bool metadata_updated;
-  base::FilePath temporary_file_path;
+  webkit_blob::ScopedFile temporary_file;
   std::string md5_checksum;
   SyncAction sync_action;
   bool clear_local_changes;
 
   ProcessRemoteChangeParam(scoped_ptr<TaskToken> token,
                            const RemoteChange& remote_change,
                            const SyncFileCallback& callback)
       : token(token.Pass()),
         remote_change(remote_change),
         callback(callback),
@@ skipping 1445 matching lines @@
     drive_metadata.set_md5_checksum(std::string());
     metadata_store_->UpdateEntry(
         url, drive_metadata,
         base::Bind(&DriveFileSyncService::CompleteRemoteSync,
                    AsWeakPtr(), base::Passed(&param)));
   }
 }
 
 void DriveFileSyncService::DownloadForRemoteSync(
     scoped_ptr<ProcessRemoteChangeParam> param) {
-  // TODO(tzik): Use ShareableFileReference here after we get thread-safe
-  // version of it. crbug.com/162598
-  base::FilePath* temporary_file_path = &param->temporary_file_path;
+  webkit_blob::ScopedFile* temporary_file = &param->temporary_file;
   content::BrowserThread::PostTaskAndReplyWithResult(
       content::BrowserThread::FILE, FROM_HERE,
-      base::Bind(&CreateTemporaryFile,
-                 temporary_file_dir_, temporary_file_path),
+      base::Bind(&CreateTemporaryFile, temporary_file_dir_, temporary_file),
       base::Bind(&DriveFileSyncService::DidGetTemporaryFileForDownload,
                  AsWeakPtr(), base::Passed(&param)));
 }
 
 void DriveFileSyncService::DidGetTemporaryFileForDownload(
     scoped_ptr<ProcessRemoteChangeParam> param,
     bool success) {
   if (!success) {
     AbortRemoteSync(param.Pass(), SYNC_FILE_ERROR_FAILED);
     return;
   }
 
-  const base::FilePath& temporary_file_path = param->temporary_file_path;
+  const base::FilePath& temporary_file_path = param->temporary_file.path();
   std::string resource_id = param->remote_change.resource_id;
+  DCHECK(!temporary_file_path.empty());
 
   // We should not use the md5 in metadata for FETCH type to avoid the download
   // finishes due to NOT_MODIFIED.
   std::string md5_checksum;
   if (param->remote_change.sync_type != REMOTE_SYNC_TYPE_FETCH)
     md5_checksum = param->drive_metadata.md5_checksum();
 
   sync_client_->DownloadFile(
       resource_id, md5_checksum,
       temporary_file_path,
@@ skipping 12 matching lines @@
   }
 
   SyncStatusCode status = GDataErrorCodeToSyncStatusCodeWrapper(error);
   if (status != SYNC_STATUS_OK) {
     AbortRemoteSync(param.Pass(), status);
     return;
   }
 
   param->drive_metadata.set_md5_checksum(md5_checksum);
   const FileChange& change = param->remote_change.change;
-  const base::FilePath& temporary_file_path = param->temporary_file_path;
+  const base::FilePath& temporary_file_path = param->temporary_file.path();
   const FileSystemURL& url = param->remote_change.url;
   remote_change_processor_->ApplyRemoteChange(
       change, temporary_file_path, url,
       base::Bind(&DriveFileSyncService::DidApplyRemoteChange,
                  AsWeakPtr(), base::Passed(&param)));
 }
 
 void DriveFileSyncService::DidApplyRemoteChange(
     scoped_ptr<ProcessRemoteChangeParam> param,
     SyncStatusCode status) {
@@ skipping 80 matching lines @@
   // remote file.
   if (param->clear_local_changes) {
     const FileSystemURL& url = param->remote_change.url;
     param->clear_local_changes = false;
     remote_change_processor_->ClearLocalChanges(
         url, base::Bind(&DriveFileSyncService::FinalizeRemoteSync,
                         AsWeakPtr(), base::Passed(&param), status));
     return;
   }
 
-  if (!param->temporary_file_path.empty())
-    DeleteTemporaryFile(param->temporary_file_path);
   NotifyTaskDone(status, param->token.Pass());
   if (status == SYNC_STATUS_OK && param->sync_action != SYNC_ACTION_NONE) {
     NotifyObserversFileStatusChanged(param->remote_change.url,
                                      SYNC_FILE_STATUS_SYNCED,
                                      param->sync_action,
                                      SYNC_DIRECTION_REMOTE_TO_LOCAL);
   }
   param->callback.Run(status, param->remote_change.url);
 }
 
@@ skipping 564 matching lines @@
       pending_batch_sync_origins_.insert(origin);
   }
   callback.Run(status, resource_id);
 }
 
 std::string DriveFileSyncService::sync_root_resource_id() {
   return metadata_store_->sync_root_directory();
 }
 
 }  // namespace sync_file_system