diff options
Diffstat (limited to 'ppapi/proxy/url_loader_resource.h')
| -rw-r--r-- | ppapi/proxy/url_loader_resource.h | 146 |
1 files changed, 146 insertions, 0 deletions
diff --git a/ppapi/proxy/url_loader_resource.h b/ppapi/proxy/url_loader_resource.h new file mode 100644 index 0000000..685ccfe --- /dev/null +++ b/ppapi/proxy/url_loader_resource.h @@ -0,0 +1,146 @@ +// Copyright (c) 2013 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/c/trusted/ppb_url_loader_trusted.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. + 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; + virtual void RegisterStatusCallback( + PP_URLLoaderTrusted_StatusCallback callback) 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_; + + PP_URLLoaderTrusted_StatusCallback status_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_
\ No newline at end of file |