Releasing the former Stadia file transfer tools

The tools allow efficient and fast synchronization of large directory
trees from a Windows workstation to a Linux target machine.

cdc_rsync* support efficient copy of files by using content-defined
chunking (CDC) to identify chunks within files that can be reused.

asset_stream_manager + cdc_fuse_fs support efficient streaming of a
local directory to a remote virtual file system based on FUSE. It also
employs CDC to identify and reuse unchanged data chunks.

common/file_watcher_win.h

@@ -0,0 +1,111 @@
+/*
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef COMMON_FILE_WATCHER_WIN_H_
+#define COMMON_FILE_WATCHER_WIN_H_
+
+#define WIN32_LEAN_AND_MEAN
+
+#include <string>
+#include <unordered_map>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/status/status.h"
+#include "absl/synchronization/mutex.h"
+
+namespace cdc_ft {
+class AsyncFileWatcher;
+
+// FileWatcherWin observes changes done in a specific directory on Windows.
+class FileWatcherWin {
+ public:
+  // Default timeout in milliseconds.
+  static constexpr unsigned int kFileWatcherTimeoutMs = 1000;
+
+  using FilesChangedCb = std::function<void()>;
+  using DirRecreatedCb = std::function<void()>;
+
+  enum class FileAction { kAdded, kModified, kDeleted };
+
+  struct FileInfo {
+    FileAction action;
+    bool is_dir;
+    uint64_t size;
+    int64_t mtime;
+
+    FileInfo(FileAction action, bool is_dir, uint64_t size, int64_t mtime)
+        : action(action), is_dir(is_dir), size(size), mtime(mtime) {}
+  };
+
+  using FileMap = std::unordered_map<std::string, FileInfo>;
+
+  explicit FileWatcherWin(std::string directory);
+  FileWatcherWin(const FileWatcherWin& other) = delete;
+  FileWatcherWin& operator=(const FileWatcherWin& other) = delete;
+
+  ~FileWatcherWin();
+
+  // Returns a map that maps relative paths of modified files to their file
+  // attributes.
+  FileMap GetModifiedFiles() ABSL_LOCKS_EXCLUDED(modified_files_mutex_);
+
+  // Starts watching directory changes.
+  // |files_changed_cb| is called on a background thread whenever files changed.
+  // |dir_recreated_cb| is called on a background thread whenever the watched
+  // directory was removed/created/re-created. It does not guarantee that the
+  // watched directory exists. The caller should check on its own and handle
+  // a case if the directory still does not exist. The callback shows that all
+  // outstanding changes are not valid anymore.
+  // |timeout_ms| is a timeout in ms for a change in the watched directory.
+  absl::Status StartWatching(FilesChangedCb files_changed_cb = FilesChangedCb(),
+                             DirRecreatedCb dir_recreated_cb = DirRecreatedCb(),
+                             unsigned int timeout_ms = kFileWatcherTimeoutMs);
+
+  // Stops watching directory changes.
+  absl::Status StopWatching() ABSL_LOCKS_EXCLUDED(modified_files_mutex_);
+
+  // Indicates whether a directory is currently watched.
+  bool IsWatching() const;
+
+  // Returns the watching status.
+  absl::Status GetStatus() const;
+
+  // Returns the total file changed events received so far.
+  // Returns 0 if the watcher is currently in stopped state.
+  uint32_t GetEventCountForTesting() const;
+
+  // Returns the total number of events for the directory changes received so
+  // far. Returns 0 if the watcher is currently in stopped state.
+  uint32_t GetDirRecreateEventCountForTesting() const;
+
+  // Enforces the use of ReadDirectoryChanges instead of ReadDirectoryChangesEx.
+  // Must be called before StartWatching.
+  void EnforceLegacyReadDirectoryChangesForTesting();
+
+ private:
+  std::string dir_path_;
+
+  std::unique_ptr<AsyncFileWatcher> async_watcher_;
+
+  absl::Mutex modified_files_mutex_;
+  FileMap modified_files_ ABSL_GUARDED_BY(modified_files_mutex_);
+
+  bool enforceLegacyReadDirectoryChangesForTesting_ = false;
+};
+
+}  // namespace cdc_ft
+
+#endif  // COMMON_FILE_WATCHER_WIN_H_