Implementation of URLLoader using PluginResource/ResourceHost.

ppapi/proxy/url_loader_resource.h

Index: ppapi/proxy/url_loader_resource.h
diff --git a/ppapi/proxy/url_loader_resource.h b/ppapi/proxy/url_loader_resource.h
new file mode 100644
index 0000000000000000000000000000000000000000..6a75b934a0546d634cbc0d066f19953058737f42
--- /dev/null
+++ b/ppapi/proxy/url_loader_resource.h
@@ -0,0 +1,141 @@
+// 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 PPAPI_PROXY_URL_LOADER_RESOURCE_H_
+#define PPAPI_PROXY_URL_LOADER_RESOURCE_H_
+
+#include <deque>
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "ppapi/proxy/plugin_resource.h"
+#include "ppapi/proxy/ppapi_proxy_export.h"
+#include "ppapi/shared_impl/url_request_info_data.h"
+#include "ppapi/thunk/ppb_url_loader_api.h"
+
+namespace ppapi {
+namespace proxy {
+
+class URLResponseInfoResource;
+
+class PPAPI_PROXY_EXPORT URLLoaderResource
+    : public PluginResource,
+      public NON_EXPORTED_BASE(thunk::PPB_URLLoader_API) {
+ public:
+  // Constructor for plugin-initiated loads.
+  URLLoaderResource(Connection connection,
+                    PP_Instance instance);
+
+  // Constructor for renderer-initiated (document) loads. The loader ID is the
+  // pending host ID for the already-created host in the renderer, and the
+  // response data is the response for the already-opened connection.

[bbudge, 2012/12/17 21:13:14]

Does a 'Connection' have a response? I thought a connection was just a pair of
IPC senders.

+  URLLoaderResource(Connection connection,
+                    PP_Instance instance,
+                    int pending_main_document_loader_id,
+                    const URLResponseInfoData& data);
+
+  virtual ~URLLoaderResource();
+
+  // Resource override.
+  thunk::PPB_URLLoader_API* AsPPB_URLLoader_API() OVERRIDE;
+
+  // PPB_URLLoader_API implementation.
+  virtual int32_t Open(PP_Resource request_id,
+                       scoped_refptr<TrackedCallback> callback) OVERRIDE;
+  virtual int32_t Open(const URLRequestInfoData& data,
+                       int requestor_pid,
+                       scoped_refptr<TrackedCallback> callback) OVERRIDE;
+  virtual int32_t FollowRedirect(
+      scoped_refptr<TrackedCallback> callback) OVERRIDE;
+  virtual PP_Bool GetUploadProgress(int64_t* bytes_sent,
+                                    int64_t* total_bytes_to_be_sent) OVERRIDE;
+  virtual PP_Bool GetDownloadProgress(
+      int64_t* bytes_received,
+      int64_t* total_bytes_to_be_received) OVERRIDE;
+  virtual PP_Resource GetResponseInfo() OVERRIDE;
+  virtual int32_t ReadResponseBody(
+      void* buffer,
+      int32_t bytes_to_read,
+      scoped_refptr<TrackedCallback> callback) OVERRIDE;
+  virtual int32_t FinishStreamingToFile(
+      scoped_refptr<TrackedCallback> callback) OVERRIDE;
+  virtual void Close() OVERRIDE;
+  virtual void GrantUniversalAccess() OVERRIDE;
+
+  // PluginResource implementation.
+  virtual void OnReplyReceived(const ResourceMessageReplyParams& params,
+                               const IPC::Message& msg) OVERRIDE;
+
+ private:
+  enum Mode {
+    // The plugin has not called Open() yet.
+    MODE_WAITING_TO_OPEN,
+
+    // The plugin is waiting for the Open() or FollowRedirect callback.
+    MODE_OPENING,
+
+    // We've started to receive data and may receive more.
+    MODE_STREAMING_DATA,
+
+    // All data has been streamed or there was an error.
+    MODE_LOAD_COMPLETE
+  };
+
+  // IPC message handlers.
+  void OnPluginMsgReceivedResponse(const ResourceMessageReplyParams& params,
+                                   const URLResponseInfoData& data);
+  void OnPluginMsgSendData(const ResourceMessageReplyParams& params,
+                           const IPC::Message& message);
+  void OnPluginMsgFinishedLoading(const ResourceMessageReplyParams& params,
+                                  int32_t result);
+  void OnPluginMsgUpdateProgress(const ResourceMessageReplyParams& params,
+                                 int64_t bytes_sent,
+                                 int64_t total_bytes_to_be_sent,
+                                 int64_t bytes_received,
+                                 int64_t total_bytes_to_be_received);
+
+  // Sends the defers loading message to the renderer to block or unblock the
+  // load.
+  void SetDefersLoading(bool defers_loading);
+
+  int32_t ValidateCallback(scoped_refptr<TrackedCallback> callback);
+
+  // Sets up |callback| as the pending callback. This should only be called once
+  // it is certain that |PP_OK_COMPLETIONPENDING| will be returned.
+  void RegisterCallback(scoped_refptr<TrackedCallback> callback);
+
+  void RunCallback(int32_t result);
+
+  // Saves the given response info to response_info_, handling file refs if
+  // necessary. This does not issue any callbacks.
+  void SaveResponseInfo(const URLResponseInfoData& data);
+
+  size_t FillUserBuffer();
+
+  Mode mode_;
+  URLRequestInfoData request_data_;
+
+  scoped_refptr<TrackedCallback> pending_callback_;
+
+  std::deque<char> buffer_;
+  int64_t bytes_sent_;
+  int64_t total_bytes_to_be_sent_;
+  int64_t bytes_received_;
+  int64_t total_bytes_to_be_received_;
+  char* user_buffer_;
+  size_t user_buffer_size_;
+  int32_t done_status_;
+  bool is_streaming_to_file_;
+  bool is_asynchronous_load_suspended_;
+
+  // The response info if we've received it.
+  scoped_refptr<URLResponseInfoResource> response_info_;
+
+  DISALLOW_COPY_AND_ASSIGN(URLLoaderResource);
+};
+
+}  // namespace proxy
+}  // namespace ppapi
+
+#endif  // PPAPI_PROXY_URL_LOADER_RESOURCE_H_