Support for file listing in privet local filesystem

List files locally using privet.

BUG=338868

Review URL: https://codereview.chromium.org/141703022

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@251936 0039d316-1c4b-4281-b951-d872f2087c98

chrome/browser/chrome_content_browser_client.cc

@@ -242,6 +242,11 @@
 #include "chrome/browser/spellchecker/spellcheck_message_filter.h"
 #endif
 
+
+#if defined(ENABLE_MDNS)
+#include "chrome/browser/local_discovery/storage/privet_filesystem_backend.h"
+#endif
+
 using blink::WebWindowFeatures;
 using base::FileDescriptor;
 using content::AccessTokenStore;
@@ -2574,12 +2579,15 @@ void ChromeContentBrowserClient::GetAdditionalFileSystemBackends(
       new sync_file_system::SyncFileSystemBackend(
           Profile::FromBrowserContext(browser_context)));
 
+#if defined(ENABLE_MDNS)
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnablePrivetStorage)) {
     additional_backends->push_back(
         new local_discovery::PrivetFileSystemBackend(
-            fileapi::ExternalMountPoints::GetSystemInstance()));
+            fileapi::ExternalMountPoints::GetSystemInstance(),
+            browser_context));
   }
+#endif
 }
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX)

chrome/browser/local_discovery/storage/path_util.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/local_discovery/storage/path_util.h"
+
+#include "base/logging.h"
+#include "base/strings/utf_string_conversions.h"
+
+namespace local_discovery {
+
+namespace {
+
+std::string UnescapeSlashes(const std::string& str) {
+  std::string output = "";
+  for (size_t i = 0; i < str.length(); i++) {
+    if (str[i] == '$') {
+      i++;
+      switch (str[i]) {
+        case 's':
+          output += '/';
+          break;
+        case 'b':
+          output += '\\';
+        break;
+        case '$':
+          output += '$';
+          break;
+        default:
+          NOTREACHED();
+      }
+    } else {
+      output += str[i];
+    }
+  }
+
+  return output;
+}
+
+const size_t kNumComponentsInBasePrivetPath = 4;
+const int kIndexOfServiceNameInComponentList = 2;
+
+std::string PathStringToString(const base::FilePath::StringType& string) {
+#if defined(OS_WIN)
+  return base::UTF16ToUTF8(string);
+#else
+  return string;
+#endif
+}
+
+}  // namespace
+
+ParsedPrivetPath::ParsedPrivetPath(const base::FilePath& file_path) {
+  std::vector<base::FilePath::StringType> components;
+  file_path.GetComponents(&components);
+  DCHECK(components.size() >= kNumComponentsInBasePrivetPath);
+  service_name = UnescapeSlashes(PathStringToString(
+      components[kIndexOfServiceNameInComponentList]));
+
+
+  for (size_t i = kNumComponentsInBasePrivetPath; i < components.size(); i++) {
+    path += '/' + PathStringToString(components[i]);
+  }
+
+  if (path.empty()) path = "/";
+}
+
+ParsedPrivetPath::~ParsedPrivetPath() {
+}
+
+}  // namespace local_discovery

chrome/browser/local_discovery/storage/path_util.h

+// 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.
+
+#ifndef CHROME_BROWSER_LOCAL_DISCOVERY_STORAGE_PATH_UTIL_H_
+#define CHROME_BROWSER_LOCAL_DISCOVERY_STORAGE_PATH_UTIL_H_
+
+#include "base/files/file_path.h"
+
+namespace local_discovery {
+
+struct ParsedPrivetPath {
+  explicit ParsedPrivetPath(const base::FilePath& path);
+  ~ParsedPrivetPath();
+
+  std::string service_name;
+  std::string path;
+};
+
+
+}  // namespace local_discovery
+
+#endif  // CHROME_BROWSER_LOCAL_DISCOVERY_STORAGE_PATH_UTIL_H_

chrome/browser/local_discovery/storage/path_util_unittest.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/local_discovery/storage/path_util.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace local_discovery {
+
+TEST(PathUtilTest, ParsePrivetPath) {
+  ParsedPrivetPath path(base::FilePath(FILE_PATH_LITERAL(
+      "/privet/MyId._privet._tcp.local/Some name/some/path")));
+
+  EXPECT_EQ("MyId._privet._tcp.local", path.service_name);
+  EXPECT_EQ("/some/path", path.path);
+}
+
+TEST(PathUtilTest, ParseEmptyPath) {
+  ParsedPrivetPath path(base::FilePath(FILE_PATH_LITERAL(
+      "/privet/MyId._privet._tcp.local/Some name/")));
+
+  EXPECT_EQ("MyId._privet._tcp.local", path.service_name);
+  EXPECT_EQ("/", path.path);
+}
+
+}  // namespace local_discovery

chrome/browser/local_discovery/storage/privet_filesystem_async_util.cc

@@ -5,11 +5,20 @@
 #include "chrome/browser/local_discovery/storage/privet_filesystem_async_util.h"
 
 #include "base/platform_file.h"
+#include "base/stl_util.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/common/blob/shareable_file_reference.h"
 
 namespace local_discovery {
 
+PrivetFileSystemAsyncUtil::PrivetFileSystemAsyncUtil(
+    content::BrowserContext* browser_context)
+    : browser_context_(browser_context) {
+}
+
+PrivetFileSystemAsyncUtil::~PrivetFileSystemAsyncUtil() {
+}
+
 void PrivetFileSystemAsyncUtil::CreateOrOpen(
     scoped_ptr<fileapi::FileSystemOperationContext> context,
     const fileapi::FileSystemURL& url,
@@ -56,17 +65,16 @@ void PrivetFileSystemAsyncUtil::ReadDirectory(
     scoped_ptr<fileapi::FileSystemOperationContext> context,
     const fileapi::FileSystemURL& url,
     const ReadDirectoryCallback& callback) {
-  EntryList entry_list;
-
-  fileapi::DirectoryEntry entry("Random file",
-                                fileapi::DirectoryEntry::FILE,
-                                3000,
-                                base::Time());
-  entry_list.push_back(entry);
-
-  callback.Run(base::File::FILE_OK, entry_list, false);
+  PrivetFileSystemAsyncOperation* operation = new PrivetFileSystemListOperation(
+      url.path(),
+      browser_context_,
+      this,
+      callback);
+  async_operations_.insert(operation);
+  operation->Start();
 }
 
+
 void PrivetFileSystemAsyncUtil::Touch(
     scoped_ptr<fileapi::FileSystemOperationContext> context,
     const fileapi::FileSystemURL& url,
@@ -151,4 +159,14 @@ void PrivetFileSystemAsyncUtil::CreateSnapshotFile(
                scoped_refptr<webkit_blob::ShareableFileReference>());
 }
 
+void PrivetFileSystemAsyncUtil::RemoveOperation(
+    PrivetFileSystemAsyncOperation* operation) {
+  async_operations_.erase(operation);
+  delete operation;
+}
+
+void PrivetFileSystemAsyncUtil::RemoveAllOperations() {
+  STLDeleteElements(&async_operations_);
+}
+
 }  // namespace local_discovery

chrome/browser/local_discovery/storage/privet_filesystem_async_util.h

@@ -5,12 +5,21 @@
 #ifndef CHROME_BROWSER_LOCAL_DISCOVERY_STORAGE_PRIVET_FILESYSTEM_ASYNC_UTIL_H_
 #define CHROME_BROWSER_LOCAL_DISCOVERY_STORAGE_PRIVET_FILESYSTEM_ASYNC_UTIL_H_
 
+#include <set>
+
+#include "chrome/browser/local_discovery/storage/privet_filesystem_operations.h"
+#include "content/public/browser/browser_context.h"
 #include "webkit/browser/fileapi/async_file_util.h"
 
 namespace local_discovery {
 
-class PrivetFileSystemAsyncUtil : public fileapi::AsyncFileUtil {
+class PrivetFileSystemAsyncUtil
+    : public fileapi::AsyncFileUtil,
+      public PrivetFileSystemAsyncOperationContainer {
  public:
+  explicit PrivetFileSystemAsyncUtil(content::BrowserContext* browser_context);
+  virtual ~PrivetFileSystemAsyncUtil();
+
   virtual void CreateOrOpen(
       scoped_ptr<fileapi::FileSystemOperationContext> context,
       const fileapi::FileSystemURL& url,
@@ -79,6 +88,16 @@ class PrivetFileSystemAsyncUtil : public fileapi::AsyncFileUtil {
       scoped_ptr<fileapi::FileSystemOperationContext> context,
       const fileapi::FileSystemURL& url,
       const CreateSnapshotFileCallback& callback) OVERRIDE;
+
+
+  virtual void RemoveOperation(
+      PrivetFileSystemAsyncOperation* operation) OVERRIDE;
+  virtual void RemoveAllOperations() OVERRIDE;
+
+ private:
+
+  std::set<PrivetFileSystemAsyncOperation*> async_operations_;
+  content::BrowserContext* browser_context_;
 };
 
 }  // namespace local_discovery

chrome/browser/local_discovery/storage/privet_filesystem_backend.cc

@@ -13,9 +13,10 @@
 namespace local_discovery {
 
 PrivetFileSystemBackend::PrivetFileSystemBackend(
-    fileapi::ExternalMountPoints* mount_points)
+    fileapi::ExternalMountPoints* mount_points,
+    content::BrowserContext* browser_context)
     : mount_points_(mount_points),
-      async_util_(new PrivetFileSystemAsyncUtil()) {
+      async_util_(new PrivetFileSystemAsyncUtil(browser_context)) {
 }
 
 PrivetFileSystemBackend::~PrivetFileSystemBackend() {

chrome/browser/local_discovery/storage/privet_filesystem_backend.h

@@ -9,6 +9,7 @@
 #include <vector>
 
 #include "base/memory/ref_counted.h"
+#include "content/public/browser/browser_context.h"
 #include "webkit/browser/blob/file_stream_reader.h"
 #include "webkit/browser/fileapi/external_mount_points.h"
 #include "webkit/browser/fileapi/file_stream_writer.h"
@@ -20,7 +21,8 @@ class PrivetFileSystemAsyncUtil;
 
 class PrivetFileSystemBackend : public fileapi::FileSystemBackend {
  public:
-  explicit PrivetFileSystemBackend(fileapi::ExternalMountPoints* mount_points);
+  PrivetFileSystemBackend(fileapi::ExternalMountPoints* mount_points,
+                          content::BrowserContext* browser_context);
   virtual ~PrivetFileSystemBackend();
 
   // FileSystemBackend implementation.

chrome/browser/local_discovery/storage/privet_filesystem_operations.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/local_discovery/storage/privet_filesystem_operations.h"
+
+namespace local_discovery {
+
+namespace {
+const char kPrivetListEntries[] = "entries";
+const char kPrivetListKeyName[] = "name";
+const char kPrivetListKeySize[] = "size";
+const char kPrivetListKeyType[] = "type";
+const char kPrivetListTypeDir[] = "dir";
+}
+
+PrivetFileSystemAsyncOperationUtil::PrivetFileSystemAsyncOperationUtil(
+    const base::FilePath& full_path,
+    net::URLRequestContextGetter* request_context,
+    Delegate* delegate)
+    : parsed_path_(full_path), request_context_(request_context),
+      delegate_(delegate) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+}
+
+PrivetFileSystemAsyncOperationUtil::~PrivetFileSystemAsyncOperationUtil() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+}
+
+void PrivetFileSystemAsyncOperationUtil::Start() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  service_discovery_client_ = ServiceDiscoverySharedClient::GetInstance();
+  privet_device_resolver_.reset(new PrivetDeviceResolver(
+      service_discovery_client_.get(),
+      parsed_path_.service_name,
+      base::Bind(
+          &PrivetFileSystemAsyncOperationUtil::OnGotDeviceDescription,
+          base::Unretained(this))));
+  privet_device_resolver_->Start();
+}
+
+void PrivetFileSystemAsyncOperationUtil::OnGotDeviceDescription(
+    bool success, const DeviceDescription& device_description) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  if (!success) {
+    delegate_->PrivetFileSystemResolved(NULL,
+                                       parsed_path_.path);
+    return;
+  }
+
+  privet_async_factory_ = PrivetHTTPAsynchronousFactory::CreateInstance(
+      service_discovery_client_.get(),
+      request_context_.get());
+  privet_http_resolution_ = privet_async_factory_->CreatePrivetHTTP(
+      parsed_path_.service_name,
+      device_description.address,
+      base::Bind(&PrivetFileSystemAsyncOperationUtil::OnGotPrivetHTTP,
+                 base::Unretained(this)));
+  privet_http_resolution_->Start();
+}
+
+void PrivetFileSystemAsyncOperationUtil::OnGotPrivetHTTP(
+    scoped_ptr<PrivetHTTPClient> privet_http_client) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  privet_client_ = privet_http_client.Pass();
+  delegate_->PrivetFileSystemResolved(privet_client_.get(),
+                                      parsed_path_.path);
+}
+
+
+PrivetFileSystemListOperation::PrivetFileSystemListOperation(
+    const base::FilePath& full_path,
+    content::BrowserContext* browser_context,
+    PrivetFileSystemAsyncOperationContainer* async_file_util,
+    const fileapi::AsyncFileUtil::ReadDirectoryCallback& callback)
+    : full_path_(full_path), browser_context_(browser_context),
+      async_file_util_(async_file_util),
+      callback_(callback), weak_factory_(this) {
+}
+
+PrivetFileSystemListOperation::~PrivetFileSystemListOperation() {
+}
+
+void PrivetFileSystemListOperation::Start() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  content::BrowserThread::PostTask(
+      content::BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(
+          &PrivetFileSystemListOperation::StartOnUIThread,
+          weak_factory_.GetWeakPtr()));
+}
+
+void PrivetFileSystemListOperation::StartOnUIThread() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  core_.reset(new PrivetFileSystemAsyncOperationUtil(
+      full_path_,
+      browser_context_->GetRequestContext(),
+      this));
+  core_->Start();
+}
+
+void PrivetFileSystemListOperation::PrivetFileSystemResolved(
+    PrivetHTTPClient* http_client,
+    const std::string& path) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+    if (!http_client) {
+      TriggerCallback(base::File::FILE_ERROR_FAILED,
+                      fileapi::AsyncFileUtil::EntryList(), false);
+      return;
+    }
+
+    list_operation_ = http_client->CreateStorageListOperation(
+        path,
+        base::Bind(&PrivetFileSystemListOperation::OnStorageListResult,
+                   base::Unretained(this)));
+    list_operation_->Start();
+}
+
+void PrivetFileSystemListOperation::TriggerCallback(
+    base::File::Error result,
+    const fileapi::AsyncFileUtil::EntryList& file_list,
+    bool has_more) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  list_operation_.reset();
+  core_.reset();
+  content::BrowserThread::PostTask(
+      content::BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(
+          &PrivetFileSystemListOperation::TriggerCallbackOnIOThread,
+          weak_factory_.GetWeakPtr(),
+          result, file_list, has_more));
+}
+
+void PrivetFileSystemListOperation::TriggerCallbackOnIOThread(
+    base::File::Error result,
+    fileapi::AsyncFileUtil::EntryList file_list,
+    bool has_more) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::IO));
+  fileapi::AsyncFileUtil::ReadDirectoryCallback callback;
+  callback = callback_;
+  async_file_util_->RemoveOperation(this);
+  callback.Run(result, file_list, has_more);
+}
+
+void PrivetFileSystemListOperation::OnStorageListResult(
+    const base::DictionaryValue* value) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  fileapi::AsyncFileUtil::EntryList entry_list;
+
+  if (!value) {
+    TriggerCallback(base::File::FILE_ERROR_FAILED,
+                    fileapi::AsyncFileUtil::EntryList(), false);
+    return;
+  }
+
+  const base::ListValue* entries;
+  if (!value->GetList(kPrivetListEntries, &entries)) {
+    TriggerCallback(base::File::FILE_ERROR_FAILED,
+                    fileapi::AsyncFileUtil::EntryList(), false);
+    return;
+  }
+
+  for (size_t i = 0; i < entries->GetSize(); i++) {
+    const base::DictionaryValue* entry_value;
+    if (!entries->GetDictionary(i, &entry_value)) {
+      TriggerCallback(base::File::FILE_ERROR_FAILED,
+                      fileapi::AsyncFileUtil::EntryList(), false);
+      return;
+    }
+
+    std::string name;
+    std::string type;
+    int size = 0;
+
+    entry_value->GetString(kPrivetListKeyName, &name);
+    entry_value->GetString(kPrivetListKeyType, &type);
+    entry_value->GetInteger(kPrivetListKeySize, &size);
+
+    fileapi::DirectoryEntry entry(
+        name,
+        (type == kPrivetListTypeDir) ?
+        fileapi::DirectoryEntry::DIRECTORY : fileapi::DirectoryEntry::FILE,
+        size,
+        base::Time() /* TODO(noamsml) */);
+
+    entry_list.push_back(entry);
+  }
+
+  TriggerCallback(base::File::FILE_OK, entry_list, false);
+}
+
+
+}  // namespace local_discovery

chrome/browser/local_discovery/storage/privet_filesystem_operations.h

+// 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.
+
+#ifndef CHROME_BROWSER_LOCAL_DISCOVERY_STORAGE_PRIVET_FILESYSTEM_OPERATIONS_H_
+#define CHROME_BROWSER_LOCAL_DISCOVERY_STORAGE_PRIVET_FILESYSTEM_OPERATIONS_H_
+
+#include "chrome/browser/local_discovery/privet_device_resolver.h"
+#include "chrome/browser/local_discovery/privet_http.h"
+#include "chrome/browser/local_discovery/privet_http_asynchronous_factory.h"
+#include "chrome/browser/local_discovery/service_discovery_shared_client.h"
+#include "chrome/browser/local_discovery/storage/path_util.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/browser_thread.h"
+#include "net/url_request/url_request_context.h"
+#include "webkit/browser/fileapi/async_file_util.h"
+
+namespace local_discovery {
+
+class PrivetFileSystemAsyncOperation {
+ public:
+  virtual ~PrivetFileSystemAsyncOperation() {}
+
+  virtual void Start() = 0;
+};
+
+class PrivetFileSystemAsyncOperationContainer {
+ public:
+  virtual ~PrivetFileSystemAsyncOperationContainer() {}
+
+  virtual void RemoveOperation(
+      PrivetFileSystemAsyncOperation* operation) = 0;
+  virtual void RemoveAllOperations() = 0;
+};
+
+class PrivetFileSystemAsyncOperationUtil {
+ public:
+  class Delegate {
+   public:
+    Delegate() {}
+    virtual ~Delegate() {}
+
+    // |http_client| is the client for the resolved service, or NULL if
+    // resolution failed. |path| is the canonical path within the privet
+    // service.
+    virtual void PrivetFileSystemResolved(
+        PrivetHTTPClient* http_client,
+        const std::string& path) = 0;
+  };
+
+  // full_path
+  PrivetFileSystemAsyncOperationUtil(
+      const base::FilePath& full_path,
+      net::URLRequestContextGetter* request_context,
+      Delegate* delegate);
+  ~PrivetFileSystemAsyncOperationUtil();
+
+  void Start();
+
+ private:
+  void OnGotDeviceDescription(bool success,
+                              const DeviceDescription& device_description);
+  void OnGotPrivetHTTP(scoped_ptr<PrivetHTTPClient> privet_http_client);
+
+  ParsedPrivetPath parsed_path_;
+  scoped_refptr<net::URLRequestContextGetter> request_context_;
+  Delegate* delegate_;
+
+  scoped_refptr<ServiceDiscoverySharedClient> service_discovery_client_;
+  scoped_ptr<PrivetDeviceResolver> privet_device_resolver_;
+  scoped_ptr<PrivetHTTPAsynchronousFactory> privet_async_factory_;
+  scoped_ptr<PrivetHTTPResolution> privet_http_resolution_;
+  scoped_ptr<PrivetHTTPClient> privet_client_;
+};
+
+class PrivetFileSystemListOperation
+    : public PrivetFileSystemAsyncOperationUtil::Delegate,
+      public local_discovery::PrivetFileSystemAsyncOperation {
+ public:
+  PrivetFileSystemListOperation(
+      const base::FilePath& full_path,
+      content::BrowserContext* browser_context,
+      PrivetFileSystemAsyncOperationContainer* async_file_util,
+      const fileapi::AsyncFileUtil::ReadDirectoryCallback& callback);
+  virtual ~PrivetFileSystemListOperation();
+
+  virtual void Start() OVERRIDE;
+
+  virtual void PrivetFileSystemResolved(
+        PrivetHTTPClient* http_client,
+        const std::string& path) OVERRIDE;
+
+ private:
+  void StartOnUIThread();
+  void OnStorageListResult(const base::DictionaryValue* value);
+  void TriggerCallback(base::File::Error result,
+                       const fileapi::AsyncFileUtil::EntryList& file_list,
+                       bool has_more);
+
+  void TriggerCallbackOnIOThread(
+      base::File::Error result,
+      fileapi::AsyncFileUtil::EntryList file_list,
+      bool has_more);
+
+  base::FilePath full_path_;
+  content::BrowserContext* browser_context_;
+  scoped_ptr<PrivetFileSystemAsyncOperationUtil> core_;
+  PrivetFileSystemAsyncOperationContainer* async_file_util_;
+  fileapi::AsyncFileUtil::ReadDirectoryCallback callback_;
+
+  scoped_ptr<PrivetJSONOperation> list_operation_;
+  base::WeakPtrFactory<PrivetFileSystemListOperation> weak_factory_;
+};
+
+}  // namespace local_discovery
+
+#endif  // CHROME_BROWSER_LOCAL_DISCOVERY_STORAGE_PRIVET_FILESYSTEM_OPERATIONS_H_

chrome/chrome_browser.gypi

@@ -1034,12 +1034,8 @@
         'browser/local_discovery/service_discovery_device_lister.h',
         'browser/local_discovery/service_discovery_shared_client.cc',
         'browser/local_discovery/service_discovery_shared_client.h',
-        'browser/local_discovery/storage/privet_filesystem_async_util.cc',
-        'browser/local_discovery/storage/privet_filesystem_async_util.h',
-        'browser/local_discovery/storage/privet_filesystem_backend.cc',
-        'browser/local_discovery/storage/privet_filesystem_backend.h',
-        'browser/local_discovery/storage/privet_filesystem_constants.cc',
-        'browser/local_discovery/storage/privet_filesystem_constants.h',
+        'browser/local_discovery/storage/path_util.cc',
+        'browser/local_discovery/storage/path_util.h',
         'browser/local_discovery/storage/privet_volume_lister.cc',
         'browser/local_discovery/storage/privet_volume_lister.h',
         'browser/mac/dock.h',
@@ -3513,8 +3509,16 @@
             'browser/local_discovery/service_discovery_client_mdns.h',
             'browser/local_discovery/service_discovery_host_client.cc',
             'browser/local_discovery/service_discovery_host_client.h',
+            'browser/local_discovery/storage/privet_filesystem_async_util.cc',
+            'browser/local_discovery/storage/privet_filesystem_async_util.h',
+            'browser/local_discovery/storage/privet_filesystem_backend.cc',
+            'browser/local_discovery/storage/privet_filesystem_backend.h',
+            'browser/local_discovery/storage/privet_filesystem_constants.cc',
+            'browser/local_discovery/storage/privet_filesystem_constants.h',
+            'browser/local_discovery/storage/privet_filesystem_operations.cc',
+            'browser/local_discovery/storage/privet_filesystem_operations.h',
             'browser/local_discovery/privet_local_printer_lister.h',
-            'browser/local_discovery/privet_local_printer_lister.cc'
+            'browser/local_discovery/privet_local_printer_lister.cc',
           ]
         }],
         ['enable_autofill_dialog!=1 or OS=="android" or OS=="ios"', {

chrome/chrome_tests_unit.gypi

@@ -1026,6 +1026,7 @@
         'browser/local_discovery/privet_confirm_api_flow_unittest.cc',
         'browser/local_discovery/privet_http_unittest.cc',
         'browser/local_discovery/privet_url_fetcher_unittest.cc',
+        'browser/local_discovery/storage/path_util_unittest.cc',
         'browser/local_discovery/cloud_print_printer_list_unittest.cc',
         'browser/local_discovery/service_discovery_client_mac_unittest.mm',
         'browser/logging_chrome_unittest.cc',