drive: Remove DriveFileType

chrome/browser/chromeos/drive/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/drive/file_system.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
@@ skipping 78 matching lines @@
 
   metadata.largest_changestamp = largest_changestamp;
   callback.Run(metadata);
 }
 
 // Thin adapter to map GetFileCallback to FileOperationCallback.
 void GetFileCallbackToFileOperationCallbackAdapter(
     const FileOperationCallback& callback,
     FileError error,
     const base::FilePath& unused_file_path,
-    const std::string& unused_mime_type,
-    DriveFileType unused_file_type) {
+    scoped_ptr<ResourceEntry> unused_entry) {
   callback.Run(error);
 }
 
 // Wraps |callback| and always passes FILE_ERROR_OK when invoked.
 // This is used for adopting |callback| to wait for a non-fatal operation.
 void IgnoreError(const FileOperationCallback& callback, FileError error) {
   callback.Run(FILE_ERROR_OK);
 }
 
 // Creates a file with unique name in |dir| and stores the path to |temp_file|.
@@ skipping 49 matching lines @@
         context(context),
         entry(entry.Pass()),
         initialized_callback(initialized_callback),
         get_file_callback(get_file_callback),
         get_content_callback(get_content_callback) {
     DCHECK(!get_file_callback.is_null());
     DCHECK(this->entry);
   }
 
   void OnError(FileError error) {
-    get_file_callback.Run(
-        error, base::FilePath(), std::string(), REGULAR_FILE);
+    get_file_callback.Run(error, base::FilePath(), scoped_ptr<ResourceEntry>());
   }
 
   void OnCacheFileFound(const base::FilePath& local_file_path) {
     if (initialized_callback.is_null()) {
       return;
     }
 
     scoped_ptr<ResourceEntry> new_entry(new ResourceEntry(*entry));
     initialized_callback.Run(FILE_ERROR_OK,
                              new_entry.Pass(),
                              local_file_path,
                              base::Closure());
   }
 
   void OnStartDownloading(const base::Closure& cancel_download_closure) {
     if (initialized_callback.is_null()) {
       return;
     }
 
     scoped_ptr<ResourceEntry> new_entry(new ResourceEntry(*entry));
     initialized_callback.Run(FILE_ERROR_OK,
                              new_entry.Pass(),
                              base::FilePath(),
                              cancel_download_closure);
   }
 
   void OnComplete(const base::FilePath& local_file_path) {
-    if (entry->file_specific_info().is_hosted_document()) {
-      get_file_callback.Run(
-          FILE_ERROR_OK, local_file_path, kMimeTypeJson, HOSTED_DOCUMENT);
-    } else {
-      get_file_callback.Run(
-          FILE_ERROR_OK, local_file_path,
-          entry->file_specific_info().content_mime_type(), REGULAR_FILE);
-    }
+    get_file_callback.Run(FILE_ERROR_OK, local_file_path,
+                          scoped_ptr<ResourceEntry>(new ResourceEntry(*entry)));
   }
 
   const base::FilePath drive_file_path;
   const DriveClientContext context;
   scoped_ptr<ResourceEntry> entry;
   const GetFileContentInitializedCallback initialized_callback;
   const GetFileCallback get_file_callback;
   const google_apis::GetContentCallback get_content_callback;
 };
 
@@ skipping 321 matching lines @@
 
 void FileSystem::OnGetEntryInfoCompleteForGetFileByPath(
     const base::FilePath& file_path,
     const GetFileCallback& callback,
     FileError error,
     scoped_ptr<ResourceEntry> entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (error != FILE_ERROR_OK) {
-    callback.Run(error, base::FilePath(), std::string(), REGULAR_FILE);
+    callback.Run(error, base::FilePath(), scoped_ptr<ResourceEntry>());
     return;
   }
   DCHECK(entry);
 
   GetResolvedFileByPath(
       make_scoped_ptr(new GetResolvedFileParams(
           file_path,
           DriveClientContext(USER_INITIATED),
           entry.Pass(),
           GetFileContentInitializedCallback(),
@@ skipping 23 matching lines @@
     const DriveClientContext& context,
     const GetFileCallback& get_file_callback,
     const google_apis::GetContentCallback& get_content_callback,
     FileError error,
     const base::FilePath& file_path,
     scoped_ptr<ResourceEntry> entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!get_file_callback.is_null());
 
   if (error != FILE_ERROR_OK) {
-    get_file_callback.Run(FILE_ERROR_NOT_FOUND,
-                          base::FilePath(),
-                          std::string(),
-                          REGULAR_FILE);
+    get_file_callback.Run(FILE_ERROR_NOT_FOUND, base::FilePath(),
+                          scoped_ptr<ResourceEntry>());
     return;
   }
 
   GetResolvedFileByPath(
       make_scoped_ptr(new GetResolvedFileParams(
           file_path,
           context,
           entry.Pass(),
           GetFileContentInitializedCallback(),
           get_file_callback,
@@ skipping 974 matching lines @@
                          callback,
                          entry_ptr->resource_id(),
                          entry_ptr->file_specific_info().file_md5())),
           google_apis::GetContentCallback())));
 }
 
 void FileSystem::OnGetFileCompleteForOpenFile(
     const GetFileCompleteForOpenParams& params,
     FileError error,
     const base::FilePath& file_path,
-    const std::string& mime_type,
-    DriveFileType file_type) {
+    scoped_ptr<ResourceEntry> entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!params.callback.is_null());
 
   if (error != FILE_ERROR_OK) {
     params.callback.Run(error, base::FilePath());
     return;
   }
 
   // OpenFile ensures that the file is a regular file.
-  DCHECK_EQ(REGULAR_FILE, file_type);
+  DCHECK(entry && !entry->file_specific_info().is_hosted_document());
 
   cache_->MarkDirty(
       params.resource_id,
       params.md5,
       base::Bind(&FileSystem::OnMarkDirtyInCacheCompleteForOpenFile,
                  weak_ptr_factory_.GetWeakPtr(),
                  params));
 }
 
 void FileSystem::OnMarkDirtyInCacheCompleteForOpenFile(
@@ skipping 195 matching lines @@
   util::ConvertPlatformFileInfoToResourceEntry(*file_info, &entry_file_info);
   *entry->mutable_file_info() = entry_file_info;
   callback.Run(FILE_ERROR_OK, entry.Pass());
 }
 
 void FileSystem::CancelJobInScheduler(JobID id) {
   scheduler_->CancelJob(id);
 }
 
 }  // namespace drive