[fsp] Add support for observing entries and notifying about changes.

chrome/browser/chromeos/extensions/file_system_provider/file_system_provider_api.cc

 // Copyright 2013 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/extensions/file_system_provider/file_system_provider_api.h"
 
 #include <string>
 #include <vector>
 
 #include "base/debug/trace_event.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_interface.h"
 #include "chrome/browser/chromeos/file_system_provider/request_manager.h"
 #include "chrome/browser/chromeos/file_system_provider/request_value.h"
 #include "chrome/browser/chromeos/file_system_provider/service.h"
 #include "chrome/common/extensions/api/file_system_provider.h"
 #include "chrome/common/extensions/api/file_system_provider_internal.h"
 
 using chromeos::file_system_provider::ProvidedFileSystemInfo;
 using chromeos::file_system_provider::ProvidedFileSystemInterface;
 using chromeos::file_system_provider::RequestValue;
 using chromeos::file_system_provider::Service;
 
 namespace extensions {
+namespace {
+
+const char kNotifyFailedErrorMessage[] =
+    "Sending a response for the request failed.";
+const char kInvalidNotificationErrorMessage[] = "The notification is invalid.";
+
+}  // namespace
 
 bool FileSystemProviderMountFunction::RunSync() {
   using api::file_system_provider::Mount::Params;
   const scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   // It's an error if the file system Id is empty.
   if (params->options.file_system_id.empty()) {
     base::ListValue* const result = new base::ListValue();
     result->Append(CreateError(kSecurityErrorName, kEmptyIdErrorMessage));
@@ skipping 12 matching lines @@
 
   Service* const service = Service::Get(GetProfile());
   DCHECK(service);
   if (!service)
     return false;
 
   // TODO(mtomasz): Pass more detailed errors, rather than just a bool.
   if (!service->MountFileSystem(extension_id(),
                                 params->options.file_system_id,
                                 params->options.display_name,
-                                params->options.writable)) {
+                                params->options.writable,
+                                params->options.supports_notify_tag)) {

[mtomasz, 2014/10/03 04:22:47]

If a file system supports_notify_tag is |true|, then when calling
chrome.fileSystemProvider.Notify |tag| must be provided, too.

The tag can be eg. a revision number for Drive notifications. The purpose of it
is to never miss any notifications, eg.:

1. Drive providing extension notifies about a /hoge-fuka.txt file being changed,
with a tag "123".
2. Chromebook is shutdown.
3. A lot of files are changed. No notification emited, because computer is off.
4. Chromebook is resumed.
5. Drive providing extension emits all notifications which happened since tag
"123".

Without tags, we can't provide continuous notifications when the computer is
off, or internet is off. Drive provides a changeId field, which can be used as
tag. Dropbox provides a tag too.

Note, that extensions may not provide a tag. If not, then notifications may not
arrive when the computer is off, or internet is off. Caching needs reliable
notifications about changes, in order to invalidate changed files. Hence, we
will enable caching only if supports_notify_tag is true.

     base::ListValue* const result = new base::ListValue();
     result->Append(CreateError(kSecurityErrorName, kMountFailedErrorMessage));
     SetResult(result);
     return true;
   }
 
   base::ListValue* result = new base::ListValue();
   SetResult(result);
   return true;
 }
@@ skipping 39 matching lines @@
     item->file_system_id = file_systems[i].file_system_id();
     item->display_name = file_systems[i].display_name();
     item->writable = file_systems[i].writable();
     items.push_back(item);
   }
 
   SetResultList(api::file_system_provider::GetAll::Results::Create(items));
   return true;
 }
 
+bool FileSystemProviderNotifyFunction::RunSync() {
+  using api::file_system_provider::Notify::Params;
+  scoped_ptr<Params> params(Params::Create(*args_));
+  EXTENSION_FUNCTION_VALIDATE(params);
+
+  Service* const service = Service::Get(GetProfile());
+  DCHECK(service);
+  if (!service)
+    return false;
+
+  ProvidedFileSystemInterface* const file_system =
+      service->GetProvidedFileSystem(extension_id(),
+                                     params->options.file_system_id);
+  if (!file_system) {
+    base::ListValue* const result = new base::ListValue();
+    result->Append(CreateError(kNotFoundErrorName, kNotifyFailedErrorMessage));
+    SetResult(result);
+    return true;
+  }
+
+  // TODO(mtomasz): Pass real data to Notify() instead of fake ones.
+  if (!file_system->Notify(

[mtomasz, 2014/10/03 04:22:47]

This is not used yet.

+          base::FilePath::FromUTF8Unsafe(params->options.observed_path),
+          chromeos::file_system_provider::ProvidedFileSystemObserver::
+              CHANGED,
+          chromeos::file_system_provider::ProvidedFileSystemObserver::
+              ChildChanges(),
+          "todo-tag")) {
+    base::ListValue* const result = new base::ListValue();
+    result->Append(
+        CreateError(kSecurityErrorName, kInvalidNotificationErrorMessage));
+    SetResult(result);
+    return true;
+  }
+
+  base::ListValue* const result = new base::ListValue();
+  SetResult(result);
+  return true;
+}
+
 bool FileSystemProviderInternalUnmountRequestedSuccessFunction::RunWhenValid() {
   using api::file_system_provider_internal::UnmountRequestedSuccess::Params;
   scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   FulfillRequest(RequestValue::CreateForUnmountSuccess(params.Pass()),
                  false /* has_more */);
   return true;
 }
 
@@ skipping 51 matching lines @@
   using api::file_system_provider_internal::OperationRequestedError::Params;
   scoped_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params);
 
   const base::File::Error error = ProviderErrorToFileError(params->error);
   RejectRequest(RequestValue::CreateForOperationError(params.Pass()), error);
   return true;
 }
 
 }  // namespace extensions