1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef CONTENT_BROWSER_LOADER_BUFFERED_RESOURCE_HANDLER_H_ 6 #define CONTENT_BROWSER_LOADER_BUFFERED_RESOURCE_HANDLER_H_ 7 8 #include <string> 9 #include <vector> 10 11 #include "base/memory/weak_ptr.h" 12 #include "content/browser/loader/layered_resource_handler.h" 13 #include "content/public/browser/resource_controller.h" 14 15 namespace net { 16 class URLRequest; 17 } 18 19 namespace content { 20 class ResourceDispatcherHostImpl; 21 struct WebPluginInfo; 22 23 // Used to buffer a request until enough data has been received. 24 class BufferedResourceHandler 25 : public LayeredResourceHandler, 26 public ResourceController { 27 public: 28 BufferedResourceHandler(scoped_ptr<ResourceHandler> next_handler, 29 ResourceDispatcherHostImpl* host, 30 net::URLRequest* request); 31 virtual ~BufferedResourceHandler(); 32 33 private: 34 // ResourceHandler implementation: 35 virtual void SetController(ResourceController* controller) OVERRIDE; 36 virtual bool OnResponseStarted(int request_id, 37 ResourceResponse* response, 38 bool* defer) OVERRIDE; 39 virtual bool OnWillRead(int request_id, 40 net::IOBuffer** buf, 41 int* buf_size, 42 int min_size) OVERRIDE; 43 virtual bool OnReadCompleted(int request_id, int bytes_read, 44 bool* defer) OVERRIDE; 45 virtual bool OnResponseCompleted(int request_id, 46 const net::URLRequestStatus& status, 47 const std::string& security_info) OVERRIDE; 48 49 // ResourceController implementation: 50 virtual void Resume() OVERRIDE; 51 virtual void Cancel() OVERRIDE; 52 virtual void CancelAndIgnore() OVERRIDE; 53 virtual void CancelWithError(int error_code) OVERRIDE; 54 55 bool ProcessResponse(bool* defer); 56 57 bool ShouldSniffContent(); 58 bool DetermineMimeType(); 59 bool SelectNextHandler(bool* defer); 60 bool UseAlternateNextHandler(scoped_ptr<ResourceHandler> handler); 61 62 bool ReplayReadCompleted(bool* defer); 63 void CallReplayReadCompleted(); 64 65 bool MustDownload(); 66 bool HasSupportingPlugin(bool* is_stale); 67 68 // Copies data from |read_buffer_| to |next_handler_|. 69 bool CopyReadBufferToNextHandler(int request_id); 70 71 // Called on the IO thread once the list of plugins has been loaded. 72 void OnPluginsLoaded(const std::vector<WebPluginInfo>& plugins); 73 74 enum State { 75 STATE_STARTING, 76 77 // In this state, we are filling read_buffer_ with data for the purpose 78 // of sniffing the mime type of the response. 79 STATE_BUFFERING, 80 81 // In this state, we are select an appropriate downstream ResourceHandler 82 // based on the mime type of the response. We are also potentially waiting 83 // for plugins to load so that we can determine if a plugin is available to 84 // handle the mime type. 85 STATE_PROCESSING, 86 87 // In this state, we are replaying buffered events (OnResponseStarted and 88 // OnReadCompleted) to the downstream ResourceHandler. 89 STATE_REPLAYING, 90 91 // In this state, we are just a blind pass-through ResourceHandler. 92 STATE_STREAMING 93 }; 94 State state_; 95 96 scoped_refptr<ResourceResponse> response_; 97 ResourceDispatcherHostImpl* host_; 98 net::URLRequest* request_; 99 scoped_refptr<net::IOBuffer> read_buffer_; 100 int read_buffer_size_; 101 int bytes_read_; 102 103 bool must_download_; 104 bool must_download_is_set_; 105 106 base::WeakPtrFactory<BufferedResourceHandler> weak_ptr_factory_; 107 108 DISALLOW_COPY_AND_ASSIGN(BufferedResourceHandler); 109 }; 110 111 } // namespace content 112 113 #endif // CONTENT_BROWSER_LOADER_BUFFERED_RESOURCE_HANDLER_H_ 114