[fsp] Add support for providing thumbnails.

chrome/browser/chromeos/file_system_provider/fake_provided_file_system.cc

 // Copyright 2014 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/file_system_provider/fake_provided_file_system.h"
 
 #include "base/files/file.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "net/base/io_buffer.h"
 
 namespace chromeos {
 namespace file_system_provider {
 namespace {
 
 const char kFakeFileName[] = "hello.txt";
 const char kFakeFileText[] =
     "This is a testing file. Lorem ipsum dolor sit amet est.";
 const size_t kFakeFileSize = sizeof(kFakeFileText) - 1u;
 const char kFakeFileModificationTime[] = "Fri Apr 25 01:47:53 UTC 2014";
 const char kFakeFileMimeType[] = "text/plain";
 
 }  // namespace
 
 const char kFakeFilePath[] = "/hello.txt";
 
+FakeEntry::FakeEntry() {
+}
+
+FakeEntry::FakeEntry(scoped_ptr<EntryMetadata> metadata,
+                     const std::string& contents)
+    : metadata(metadata.Pass()), contents(contents) {
+}
+
+FakeEntry::~FakeEntry() {
+}
+
 FakeProvidedFileSystem::FakeProvidedFileSystem(
     const ProvidedFileSystemInfo& file_system_info)
     : file_system_info_(file_system_info),
       last_file_handle_(0),
       weak_ptr_factory_(this) {
   AddEntry(
       base::FilePath::FromUTF8Unsafe("/"), true, "", 0, base::Time(), "", "");
 
   base::Time modification_time;
   DCHECK(base::Time::FromString(kFakeFileModificationTime, &modification_time));
   AddEntry(base::FilePath::FromUTF8Unsafe(kFakeFilePath),
            false,
            kFakeFileName,
            kFakeFileSize,
            modification_time,
            kFakeFileMimeType,
            kFakeFileText);
 }
 
 FakeProvidedFileSystem::~FakeProvidedFileSystem() {}
 
 void FakeProvidedFileSystem::AddEntry(const base::FilePath& entry_path,
                                       bool is_directory,
                                       const std::string& name,
                                       int64 size,
                                       base::Time modification_time,
                                       std::string mime_type,
                                       std::string contents) {
   DCHECK(entries_.find(entry_path) == entries_.end());
-  EntryMetadata metadata;
+  scoped_ptr<EntryMetadata> metadata(new EntryMetadata);
 
-  metadata.is_directory = is_directory;
-  metadata.name = name;
-  metadata.size = size;
-  metadata.modification_time = modification_time;
-  metadata.mime_type = mime_type;
+  metadata->is_directory = is_directory;
+  metadata->name = name;
+  metadata->size = size;
+  metadata->modification_time = modification_time;
+  metadata->mime_type = mime_type;
 
-  entries_[entry_path] = FakeEntry(metadata, contents);
+  entries_[entry_path] =
+      make_linked_ptr(new FakeEntry(metadata.Pass(), contents));
 }
 
-bool FakeProvidedFileSystem::GetEntry(const base::FilePath& entry_path,
-                                      FakeEntry* fake_entry) const {
+const FakeEntry* FakeProvidedFileSystem::GetEntry(
+    const base::FilePath& entry_path) const {
   const Entries::const_iterator entry_it = entries_.find(entry_path);
   if (entry_it == entries_.end())
-    return false;
+    return NULL;
 
-  *fake_entry = entry_it->second;
-  return true;
+  return entry_it->second.get();
 }
 
 ProvidedFileSystemInterface::AbortCallback
 FakeProvidedFileSystem::RequestUnmount(
     const storage::AsyncFileUtil::StatusCallback& callback) {
   return PostAbortableTask(base::Bind(callback, base::File::FILE_OK));
 }
 
 ProvidedFileSystemInterface::AbortCallback FakeProvidedFileSystem::GetMetadata(
     const base::FilePath& entry_path,
+    ProvidedFileSystemInterface::MetadataFieldMask fields,
     const ProvidedFileSystemInterface::GetMetadataCallback& callback) {
   const Entries::const_iterator entry_it = entries_.find(entry_path);
 
   if (entry_it == entries_.end()) {
-    return PostAbortableTask(base::Bind(
-        callback, EntryMetadata(), base::File::FILE_ERROR_NOT_FOUND));
+    return PostAbortableTask(
+        base::Bind(callback,
+                   base::Passed(make_scoped_ptr<EntryMetadata>(NULL)),
+                   base::File::FILE_ERROR_NOT_FOUND));
   }
 
+  scoped_ptr<EntryMetadata> metadata(new EntryMetadata);
+  metadata->is_directory = entry_it->second->metadata->is_directory;
+  metadata->name = entry_it->second->metadata->name;
+  metadata->size = entry_it->second->metadata->size;
+  metadata->modification_time = entry_it->second->metadata->modification_time;
+  metadata->mime_type = entry_it->second->metadata->mime_type;
+  metadata->thumbnail = entry_it->second->metadata->thumbnail;
+
   return PostAbortableTask(
-      base::Bind(callback, entry_it->second.metadata, base::File::FILE_OK));
+      base::Bind(callback, base::Passed(&metadata), base::File::FILE_OK));
 }
 
 ProvidedFileSystemInterface::AbortCallback
 FakeProvidedFileSystem::ReadDirectory(
     const base::FilePath& directory_path,
     const storage::AsyncFileUtil::ReadDirectoryCallback& callback) {
   storage::AsyncFileUtil::EntryList entry_list;
 
   for (Entries::const_iterator it = entries_.begin(); it != entries_.end();
        ++it) {
     const base::FilePath file_path = it->first;
     if (file_path == directory_path || directory_path.IsParent(file_path)) {
-      const EntryMetadata& metadata = it->second.metadata;
+      scoped_ptr<EntryMetadata>& metadata = it->second->metadata;

[hirono, 2014/08/29 06:02:41]

const scoped_ptr<EntryMetadta>& ?
or just EntryMetadata* ?

[mtomasz, 2014/08/29 06:17:48]

Done.

       entry_list.push_back(storage::DirectoryEntry(
-          metadata.name,
-          metadata.is_directory ? storage::DirectoryEntry::DIRECTORY
-                                : storage::DirectoryEntry::FILE,
-          metadata.size,
-          metadata.modification_time));
+          metadata->name,
+          metadata->is_directory ? storage::DirectoryEntry::DIRECTORY
+                                 : storage::DirectoryEntry::FILE,
+          metadata->size,
+          metadata->modification_time));
     }
   }
 
   return PostAbortableTask(base::Bind(
       callback, base::File::FILE_OK, entry_list, false /* has_more */));
 }
 
 ProvidedFileSystemInterface::AbortCallback FakeProvidedFileSystem::OpenFile(
     const base::FilePath& entry_path,
     OpenFileMode mode,
@@ skipping 52 matching lines @@
                    0 /* chunk_length */,
                    false /* has_more */,
                    base::File::FILE_ERROR_INVALID_OPERATION));
   }
 
   // Send the response byte by byte.
   int64 current_offset = offset;
   int current_length = length;
 
   // Reading behind EOF is fine, it will just return 0 bytes.
-  if (current_offset >= entry_it->second.metadata.size || !current_length) {
+  if (current_offset >= entry_it->second->metadata->size || !current_length) {
     return PostAbortableTask(base::Bind(callback,
                                         0 /* chunk_length */,
                                         false /* has_more */,
                                         base::File::FILE_OK));
   }
 
-  const FakeEntry& entry = entry_it->second;
+  const FakeEntry* const entry = entry_it->second.get();
   std::vector<int> task_ids;
-  while (current_offset < entry.metadata.size && current_length) {
-    buffer->data()[current_offset - offset] = entry.contents[current_offset];
+  while (current_offset < entry->metadata->size && current_length) {
+    buffer->data()[current_offset - offset] = entry->contents[current_offset];
     const bool has_more =
-        (current_offset + 1 < entry.metadata.size) && (current_length - 1);
+        (current_offset + 1 < entry->metadata->size) && (current_length - 1);
     const int task_id = tracker_.PostTask(
         base::MessageLoopProxy::current(),
         FROM_HERE,
         base::Bind(
             callback, 1 /* chunk_length */, has_more, base::File::FILE_OK));
     task_ids.push_back(task_id);
     current_offset++;
     current_length--;
   }
 
@@ skipping 68 matching lines @@
     return PostAbortableTask(
         base::Bind(callback, base::File::FILE_ERROR_INVALID_OPERATION));
   }
 
   const Entries::iterator entry_it = entries_.find(opened_file_it->second);
   if (entry_it == entries_.end()) {
     return PostAbortableTask(
         base::Bind(callback, base::File::FILE_ERROR_INVALID_OPERATION));
   }
 
-  FakeEntry* const entry = &entry_it->second;
-  if (offset > entry->metadata.size) {
+  FakeEntry* const entry = entry_it->second.get();
+  if (offset > entry->metadata->size) {
     return PostAbortableTask(
         base::Bind(callback, base::File::FILE_ERROR_INVALID_OPERATION));
   }
 
   // Allocate the string size in advance.
-  if (offset + length > entry->metadata.size) {
-    entry->metadata.size = offset + length;
-    entry->contents.resize(entry->metadata.size);
+  if (offset + length > entry->metadata->size) {
+    entry->metadata->size = offset + length;
+    entry->contents.resize(entry->metadata->size);
   }
 
   entry->contents.replace(offset, length, buffer->data(), length);
 
   return PostAbortableTask(base::Bind(callback, base::File::FILE_OK));
 }
 
 const ProvidedFileSystemInfo& FakeProvidedFileSystem::GetFileSystemInfo()
     const {
   return file_system_info_;
@@ skipping 34 matching lines @@
     const std::vector<int>& task_ids,
     const storage::AsyncFileUtil::StatusCallback& callback) {
   for (size_t i = 0; i < task_ids.size(); ++i) {
     tracker_.TryCancel(task_ids[i]);
   }
   callback.Run(base::File::FILE_OK);
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos