Add Stream support to WebBlobRegistry and FileAPIMessageFilter.

content/browser/fileapi/fileapi_message_filter.h

 // Copyright (c) 2012 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 CONTENT_BROWSER_FILEAPI_FILEAPI_MESSAGE_FILTER_H_
 #define CONTENT_BROWSER_FILEAPI_FILEAPI_MESSAGE_FILTER_H_
 
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/files/file_util_proxy.h"
 #include "base/id_map.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/shared_memory.h"
 #include "base/platform_file.h"
+#include "content/browser/streams/stream.h"
+#include "content/browser/streams/stream_context.h"
 #include "content/common/content_export.h"
 #include "content/public/browser/browser_message_filter.h"
 #include "webkit/browser/fileapi/file_system_operation_runner.h"
 #include "webkit/common/blob/blob_data.h"
 #include "webkit/common/fileapi/file_system_types.h"
 #include "webkit/common/quota/quota_types.h"
 
 class GURL;
 
 namespace base {
@@ skipping 13 matching lines @@
 class URLRequestContextGetter;
 }  // namespace net
 
 namespace webkit_blob {
 class ShareableFileReference;
 }
 
 namespace content {
 class ChromeBlobStorageContext;
 
+// TODO(tyoshino): Factor out code except for IPC gluing from
+// FileAPIMessageFilter into separate classes. See crbug.com/263741.
 class CONTENT_EXPORT FileAPIMessageFilter : public BrowserMessageFilter {
  public:
   // Used by the renderer process host on the UI thread.
   FileAPIMessageFilter(
       int process_id,
       net::URLRequestContextGetter* request_context_getter,
       fileapi::FileSystemContext* file_system_context,
-      ChromeBlobStorageContext* blob_storage_context);
+      ChromeBlobStorageContext* blob_storage_context,
+      StreamContext* stream_context);
   // Used by the worker process host on the IO thread.
   FileAPIMessageFilter(
       int process_id,
       net::URLRequestContext* request_context,
       fileapi::FileSystemContext* file_system_context,
-      ChromeBlobStorageContext* blob_storage_context);
+      ChromeBlobStorageContext* blob_storage_context,
+      StreamContext* stream_context);
 
   // BrowserMessageFilter implementation.
   virtual void OnChannelConnected(int32 peer_pid) OVERRIDE;
   virtual void OnChannelClosing() OVERRIDE;
   virtual base::TaskRunner* OverrideTaskRunnerForMessage(
       const IPC::Message& message) OVERRIDE;
   virtual bool OnMessageReceived(const IPC::Message& message,
                                  bool* message_was_ok) OVERRIDE;
 
  protected:
@@ skipping 40 matching lines @@
   void OnOpenFile(int request_id, const GURL& path, int file_flags);
   void OnNotifyCloseFile(int file_open_id);
   void OnWillUpdate(const GURL& path);
   void OnDidUpdate(const GURL& path, int64 delta);
   void OnSyncGetPlatformPath(const GURL& path,
                              base::FilePath* platform_path);
   void OnCreateSnapshotFile(int request_id,
                             const GURL& path);
   void OnDidReceiveSnapshotFile(int request_id);
 
+  // Handlers for BlobHostMsg_ family messages.
+
   void OnStartBuildingBlob(const GURL& url);
-  void OnAppendBlobDataItem(const GURL& url,
-                            const webkit_blob::BlobData::Item& item);
-  void OnAppendSharedMemory(const GURL& url, base::SharedMemoryHandle handle,
-                            size_t buffer_size);
+  void OnAppendBlobDataItemToBlob(
+      const GURL& url, const webkit_blob::BlobData::Item& item);
+  void OnAppendSharedMemoryToBlob(
+      const GURL& url, base::SharedMemoryHandle handle, size_t buffer_size);
   void OnFinishBuildingBlob(const GURL& url, const std::string& content_type);
   void OnCloneBlob(const GURL& url, const GURL& src_url);
   void OnRemoveBlob(const GURL& url);
 
+  // Handlers for StreamHostMsg_ family messages.
+  //
+  // TODO(tyoshino): Consider renaming BlobData to more generic one as it's now
+  // used for Stream.
+
+  // Currently |content_type| is ignored.
+  //
+  // TODO(tyoshino): Set |content_type| to the stream.
+  void OnStartBuildingStream(const GURL& url, const std::string& content_type);
+  void OnAppendBlobDataItemToStream(
+      const GURL& url, const webkit_blob::BlobData::Item& item);
+  void OnAppendSharedMemoryToStream(
+      const GURL& url, base::SharedMemoryHandle handle, size_t buffer_size);
+  void OnFinishBuildingStream(const GURL& url);
+  void OnCloneStream(const GURL& url, const GURL& src_url);
+  void OnRemoveStream(const GURL& url);
+
   // Callback functions to be used when each file operation is finished.
   void DidFinish(int request_id, base::PlatformFileError result);
   void DidCancel(int request_id, base::PlatformFileError result);
   void DidGetMetadata(int request_id,
                       base::PlatformFileError result,
                       const base::PlatformFileInfo& info);
   void DidReadDirectory(int request_id,
                         base::PlatformFileError result,
                         const std::vector<fileapi::DirectoryEntry>& entries,
                         bool has_more);
@@ skipping 19 matching lines @@
       base::PlatformFileError result,
       const base::PlatformFileInfo& info,
       const base::FilePath& platform_path,
       const scoped_refptr<webkit_blob::ShareableFileReference>& file_ref);
 
   // Checks renderer's access permissions for single file.
   bool HasPermissionsForFile(const fileapi::FileSystemURL& url,
                              int permissions,
                              base::PlatformFileError* error);
 
+  // Retrieves the Stream object for |url| from |stream_context_|.
+  scoped_refptr<Stream> GetStreamForURL(const GURL& url);
+
   fileapi::FileSystemOperationRunner* operation_runner() {
     return operation_runner_.get();
   }
 
   int process_id_;
 
   fileapi::FileSystemContext* context_;
 
   // Keeps map from request_id to OperationID for ongoing operations.
   // (Primarily for Cancel operation)
   typedef std::map<int, OperationID> OperationsMap;
   OperationsMap operations_;
 
   // The getter holds the context until Init() can be called from the
   // IO thread, which will extract the net::URLRequestContext from it.
   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
   net::URLRequestContext* request_context_;
 
   scoped_refptr<ChromeBlobStorageContext> blob_storage_context_;
+  scoped_refptr<StreamContext> stream_context_;
 
   scoped_ptr<fileapi::FileSystemOperationRunner> operation_runner_;
 
   // Keep track of blob URLs registered in this process. Need to unregister
   // all of them when the renderer process dies.
   base::hash_set<std::string> blob_urls_;
 
+  // Keep track of stream URLs registered in this process. Need to unregister
+  // all of them when the renderer process dies.
+  base::hash_set<std::string> stream_urls_;
+
   // Used to keep snapshot files alive while a DidCreateSnapshot
   // is being sent to the renderer.
   std::map<int, scoped_refptr<webkit_blob::ShareableFileReference> >
       in_transit_snapshot_files_;
 
   // Keep track of file system file opened by OpenFile() in this process.
   // Need to close all of them when the renderer process dies.
   typedef IDMap<base::Closure, IDMapOwnPointer> OnCloseCallbackMap;
   OnCloseCallbackMap on_close_callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(FileAPIMessageFilter);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_FILEAPI_FILEAPI_MESSAGE_FILTER_H_