Declare providing extension capabilities in the manifest.

chrome/common/extensions/api/file_system_provider/file_system_provider_handler.cc

+// Copyright 2015 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/common/extensions/api/file_system_provider/file_system_provider_handler.h"
+
+#include "base/memory/scoped_ptr.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/values.h"
+#include "chrome/common/extensions/api/file_system_provider.h"
+#include "extensions/common/error_utils.h"
+#include "extensions/common/manifest_constants.h"
+#include "url/gurl.h"
+
+namespace extensions {
+
+namespace mkeys = manifest_keys;
+namespace merrors = manifest_errors;
+
+FileSystemProviderCapabilities::FileSystemProviderCapabilities()
+    : configurable_(false), multiple_mounts_(false), source_(SOURCE_FILE) {
+}
+
+FileSystemProviderCapabilities::FileSystemProviderCapabilities(
+    bool configurable,
+    bool multiple_mounts,
+    FileSystemProviderSource source)
+    : configurable_(configurable),
+      multiple_mounts_(multiple_mounts),
+      source_(source) {
+}
+
+FileSystemProviderCapabilities::~FileSystemProviderCapabilities() {
+}
+
+FileSystemProviderHandler::FileSystemProviderHandler() {
+}
+
+FileSystemProviderHandler::~FileSystemProviderHandler() {
+}
+
+// static
+const FileSystemProviderCapabilities* FileSystemProviderCapabilities::Get(
+    const Extension* extension) {
+  return static_cast<FileSystemProviderCapabilities*>(
+      extension->GetManifestData(mkeys::kFileSystemProvider));
+}
+
+bool FileSystemProviderHandler::Parse(Extension* extension,
+                                      base::string16* error) {
+  const base::DictionaryValue* section = NULL;
+  if (!extension->manifest()->GetDictionary(mkeys::kFileSystemProvider,
+                                            &section)) {
+    *error = base::ASCIIToUTF16(merrors::kInvalidFileSystemProvider);
+    return false;
+  }
+
+  api::file_system_provider::Capabilities idl_capabilities;
+  if (!api::file_system_provider::Capabilities::Populate(*section,
+                                                         &idl_capabilities)) {

[not at google - send to devlin, 2015/04/24 17:49:31]

Btw, the nice thing about using manifest_types.json is that it has:

   "compiler_options": {
      "generate_error_messages": true
    },

which means that instead of having a single "failed" you get "failed
because...", and it also warns if there was something malformed that it managed
to parse anyway (e.g. an extra field, or an optional value that didn't parse".
Generally speaking I think it's nicer to gracefully recover from failing to
parse a manifest key, rather than entirely failing the installation of an
extension. In this case, it means writing out to the warnings, rather than
populating an error.

with that in mind, it would be good to make that a per-type annotation, so that
we can avoid adding "generate_error_messages" to the entire API.  I think that
would actually be tricky because you'd need to know how to transitively apply
the warning messages across other types.

Therefore, perhaps try just putting the "generate_error_messages" annotation on
the file system providers API and see if it (a) compiles, (b) doesn't add a
significant binary size increase. If not, consider moving the type into
manifest_types.json after all, if you think that the advantages there outweigh
the cost here. Ultimately the API and the documentation will be the same, with
better messages/recovery on failure - it's just some extra complexity on the
implementation side - but not too much, I think.

[mtomasz, 2015/04/24 17:54:01]

Wow. I didn't know about "generate_error_messages". I was even thinking about
adding such feature. So good it's already there.

I have to run from the office. I'll address other comments once I'm back to the
office (next week).

[mtomasz, 2015/05/07 03:33:59]

Done. Moved to manifest_types.json.

+    *error = base::ASCIIToUTF16(merrors::kInvalidFileSystemProvider);
+    return false;
+  }
+
+  FileSystemProviderSource source = SOURCE_FILE;
+  switch (idl_capabilities.source) {
+    case ::extensions::api::file_system_provider::SOURCE_FILE:

[not at google - send to devlin, 2015/04/24 17:49:31]

you're already in the extensions namespace, do you really need the ::extensions
out the front of these?

[mtomasz, 2015/05/07 03:33:59]

Done.

+      source = SOURCE_FILE;
+      break;
+    case ::extensions::api::file_system_provider::SOURCE_DEVICE:
+      source = SOURCE_DEVICE;
+      break;
+    case ::extensions::api::file_system_provider::SOURCE_NETWORK:
+      source = SOURCE_NETWORK;
+      break;
+    case ::extensions::api::file_system_provider::SOURCE_NONE:
+      NOTREACHED();
+  }
+
+  scoped_ptr<FileSystemProviderCapabilities> capabilities(
+      new FileSystemProviderCapabilities(idl_capabilities.configurable,
+                                         idl_capabilities.multiple_mounts,
+                                         source));
+
+  extension->SetManifestData(mkeys::kFileSystemProvider,
+                             capabilities.release());
+  return true;
+}
+
+const std::vector<std::string> FileSystemProviderHandler::Keys() const {
+  return SingleKey(mkeys::kFileSystemProvider);
+}
+
+}  // namespace extensions