gdata: Upload locally modified file in the correct size.

chrome/browser/chromeos/gdata/gdata_file_system.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/chromeos/gdata/gdata_file_system.h"
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 297 matching lines @@
     LOG(WARNING) << "GData metadata file can't be stored at "
                  << file_path.value();
     if (!file_util::Delete(file_path, true)) {
       LOG(WARNING) << "GData metadata file can't be deleted at "
                    << file_path.value();
       return;
     }
   }
 }
 
+// Gets the file size of |local_file|.
+void GetLocalFileSizeOnBlockingPool(const FilePath& local_file,
+                                    GDataFileError* error,
+                                    int64* file_size) {
+  DCHECK(error);
+  DCHECK(file_size);
+
+  *file_size = 0;
+  *error = file_util::GetFileSize(local_file, file_size) ?
+      GDATA_FILE_OK :
+      GDATA_FILE_ERROR_NOT_FOUND;
+}
+
 // Gets the file size and the content type of |local_file|.
 void GetLocalFileInfoOnBlockingPool(
     const FilePath& local_file,
     GDataFileError* error,
     int64* file_size,
     std::string* content_type) {
   DCHECK(error);
   DCHECK(file_size);
   DCHECK(content_type);
 
@@ skipping 257 matching lines @@
     base::SequencedTaskRunner* blocking_task_runner,
     const base::Closure& request_task,
     const base::Closure& reply_task) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const bool posted = blocking_task_runner->PostTaskAndReply(
       from_here, request_task, reply_task);
   DCHECK(posted);
 }
 
+// Helper function for binding |path| to GetEntryInfoWithFilePathCallback and
+// create GetEntryInfoCallback.
+void RunGetEntryInfoWithFilePathCallback(

[satorux1, 2012/07/25 19:07:14]

this seems to be unused.

[kinaba, 2012/07/26 01:29:51]

Right. Thanks.

+    const GetEntryInfoWithFilePathCallback& callback,
+    const FilePath& path,
+    GDataFileError error,
+    scoped_ptr<GDataEntryProto> entry_proto) {
+  if (!callback.is_null())
+    callback.Run(error, path, entry_proto.Pass());
+}
+
 }  // namespace
 
 // GDataFileSystem::GetDocumentsParams struct implementation.
 struct GDataFileSystem::GetDocumentsParams {
   GetDocumentsParams(int start_changestamp,
                      int root_feed_changestamp,
                      std::vector<DocumentFeed*>* feed_list,
                      bool should_fetch_multiple_feeds,
                      const FilePath& search_file_path,
                      const std::string& search_query,
@@ skipping 1890 matching lines @@
     const std::string& md5,
     const FilePath& cache_file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != GDATA_FILE_OK) {
     if (!callback.is_null())
       callback.Run(error);
     return;
   }
 
+  // Gets the size of the cache file. Since the file is locally modified, the
+  // file size information stored in GDataEntry is not correct.
+  GDataFileError* get_size_error = new GDataFileError(GDATA_FILE_ERROR_FAILED);
+  int64* file_size = new int64(-1);
+  PostBlockingPoolSequencedTaskAndReply(
+      FROM_HERE,
+      blocking_task_runner_,
+      base::Bind(&GetLocalFileSizeOnBlockingPool,
+                 cache_file_path,
+                 get_size_error,
+                 file_size),
+      base::Bind(&GDataFileSystem::OnGetFileSizeCompleteForUpdateFile,
+                 ui_weak_ptr_,
+                 callback,
+                 resource_id,
+                 md5,
+                 cache_file_path,
+                 base::Owned(get_size_error),
+                 base::Owned(file_size)));
+}
+
+void GDataFileSystem::OnGetFileSizeCompleteForUpdateFile(
+    const FileOperationCallback& callback,
+    const std::string& resource_id,
+    const std::string& md5,
+    const FilePath& cache_file_path,
+    GDataFileError* error,
+    int64* file_size) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  if (*error != GDATA_FILE_OK) {
+    if (!callback.is_null())
+      callback.Run(*error);
+    return;
+  }
+
   directory_service_->GetEntryByResourceIdAsync(resource_id,
       base::Bind(&GDataFileSystem::OnGetFileCompleteForUpdateFileByEntry,
           ui_weak_ptr_,
           callback,
           md5,
+          *file_size,
           cache_file_path));
 }
 
 void GDataFileSystem::OnGetFileCompleteForUpdateFileByEntry(
     const FileOperationCallback& callback,
     const std::string& md5,
+    int64 file_size,
     const FilePath& cache_file_path,
     GDataEntry* entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!entry || !entry->AsGDataFile()) {
     if (!callback.is_null())
       callback.Run(GDATA_FILE_ERROR_NOT_FOUND);
     return;
   }
   GDataFile* file = entry->AsGDataFile();
 
   uploader_->UploadExistingFile(
       file->upload_url(),
       file->GetFilePath(),
       cache_file_path,
-      file->file_info().size,
+      file_size,
       file->content_mime_type(),
       base::Bind(&GDataFileSystem::OnUpdatedFileUploaded,
                  ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::OnUpdatedFileUploaded(
     const FileOperationCallback& callback,
     GDataFileError error,
     scoped_ptr<UploadFileInfo> upload_file_info) {
@@ skipping 1569 matching lines @@
   // must go through here. Removes the |file_path| from the remembered set so
   // that subsequent operations can open the file again.
   open_files_.erase(file_path);
 
   // Then invokes the user-supplied callback function.
   if (!callback.is_null())
     callback.Run(result);
 }
 
 }  // namespace gdata