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) {
+  const FileSystemProviderCapabilities* const capabilities =
+      static_cast<FileSystemProviderCapabilities*>(
+          extension->GetManifestData(mkeys::kFileSystemProvider));
+  return capabilities;

[not at google - send to devlin, 2015/04/24 16:18:32]

just return the expression from lines 45-47, without the intermediate
assignment?

[mtomasz, 2015/04/24 17:12:10]

Done.

+}
+
+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)) {
+    *error = base::ASCIIToUTF16(merrors::kInvalidFileSystemProvider);
+    return false;
+  }
+
+  FileSystemProviderSource source = SOURCE_FILE;
+  switch (idl_capabilities.source) {
+    case ::extensions::api::file_system_provider::SOURCE_FILE:
+      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