OLD | NEW |
---|---|
1 // Copyright (c) 2010 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2010 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #ifndef PDF_DOCUMENT_LOADER_H_ | 5 #ifndef PDF_DOCUMENT_LOADER_H_ |
6 #define PDF_DOCUMENT_LOADER_H_ | 6 #define PDF_DOCUMENT_LOADER_H_ |
7 | 7 |
8 #include <stddef.h> | 8 #include <stddef.h> |
9 #include <stdint.h> | 9 #include <stdint.h> |
10 | 10 |
11 #include <list> | 11 #include <list> |
12 #include <memory> | |
12 #include <string> | 13 #include <string> |
13 #include <utility> | 14 #include <utility> |
14 #include <vector> | 15 #include <vector> |
15 | 16 |
16 #include "pdf/chunk_stream.h" | 17 #include "pdf/chunk_stream.h" |
17 #include "ppapi/cpp/url_loader.h" | |
18 #include "ppapi/utility/completion_callback_factory.h" | 18 #include "ppapi/utility/completion_callback_factory.h" |
19 | 19 |
20 namespace chrome_pdf { | 20 namespace chrome_pdf { |
21 | 21 |
22 class URLLoaderWrapper; | |
23 | |
22 class DocumentLoader { | 24 class DocumentLoader { |
23 public: | 25 public: |
26 // Number was chosen in crbug.com/78264#c8 | |
27 enum { kDefaultRequestSize = 65536 }; | |
spelchat
2016/10/12 00:35:31
Any reason why this is public?
snake
2016/10/14 11:31:17
It is used in tests. More easy, that declare "frie
| |
28 | |
24 class Client { | 29 class Client { |
25 public: | 30 public: |
26 virtual ~Client(); | 31 virtual ~Client(); |
27 | 32 |
28 // Gets the pp::Instance object. | 33 // Gets the pp::Instance object. |
29 virtual pp::Instance* GetPluginInstance() = 0; | 34 virtual pp::Instance* GetPluginInstance() = 0; |
30 // Creates new URLLoader based on client settings. | 35 // Creates new URLLoader based on client settings. |
31 virtual pp::URLLoader CreateURLLoader() = 0; | 36 virtual std::unique_ptr<URLLoaderWrapper> CreateURLLoader() = 0; |
32 // Notification called when partial information about document is available. | |
33 // Only called for urls that returns full content size and supports byte | |
34 // range requests. | |
35 virtual void OnPartialDocumentLoaded() = 0; | |
36 // Notification called when all outstanding pending requests are complete. | 37 // Notification called when all outstanding pending requests are complete. |
37 virtual void OnPendingRequestComplete() = 0; | 38 virtual void OnPendingRequestComplete() = 0; |
38 // Notification called when new data is available. | 39 // Notification called when new data is available. |
39 virtual void OnNewDataAvailable() = 0; | 40 virtual void OnNewDataAvailable() = 0; |
40 // Notification called when document is fully loaded. | 41 // Notification called when document is fully loaded. |
41 virtual void OnDocumentComplete() = 0; | 42 virtual void OnDocumentComplete() = 0; |
43 // Notification called when document loading is canceled. | |
44 virtual void OnDocumentCanceled() = 0; | |
45 // Called when initial loader was closed. | |
46 virtual void CancelBrowserDownload() = 0; | |
42 }; | 47 }; |
43 | 48 |
44 explicit DocumentLoader(Client* client); | 49 explicit DocumentLoader(Client* client); |
45 ~DocumentLoader(); | 50 ~DocumentLoader(); |
46 | 51 |
47 bool Init(const pp::URLLoader& loader, | 52 bool Init(std::unique_ptr<URLLoaderWrapper> loader, const std::string& url); |
48 const std::string& url, | |
49 const std::string& headers); | |
50 | 53 |
51 // Data access interface. Return true is successful. | 54 // Data access interface. Return true is successful. |
52 bool GetBlock(uint32_t position, uint32_t size, void* buf) const; | 55 bool GetBlock(uint32_t position, uint32_t size, void* buf) const; |
53 | 56 |
54 // Data availability interface. Return true data available. | 57 // Data availability interface. Return true data available. |
55 bool IsDataAvailable(uint32_t position, uint32_t size) const; | 58 bool IsDataAvailable(uint32_t position, uint32_t size) const; |
56 | 59 |
57 // Data availability interface. Return true data available. | 60 // Data availability interface. Return true data available. |
58 void RequestData(uint32_t position, uint32_t size); | 61 void RequestData(uint32_t position, uint32_t size); |
59 | 62 |
60 bool IsDocumentComplete() const; | 63 bool IsDocumentComplete() const; |
61 uint32_t document_size() const { return document_size_; } | 64 uint32_t GetDocumentSize() const; |
62 | 65 float GetProgress() const; |
63 // Return number of bytes available. | |
64 uint32_t GetAvailableData() const; | |
65 | 66 |
66 // Clear pending requests from the queue. | 67 // Clear pending requests from the queue. |
67 void ClearPendingRequests(); | 68 void ClearPendingRequests(); |
68 | 69 |
69 bool is_partial_document() const { return partial_document_; } | 70 void SetPartialLoadingEnabled(bool enabled); |
71 | |
72 bool is_partial_loader_active() const { return is_partial_loader_active_; } | |
70 | 73 |
71 private: | 74 private: |
75 typedef ChunkStream<kDefaultRequestSize> DataStream; | |
76 struct Chunk { | |
77 Chunk(); | |
78 ~Chunk(); | |
79 | |
80 void Clear(); | |
81 | |
82 uint32_t chunk_index = 0; | |
83 uint32_t data_size = 0; | |
84 std::unique_ptr<DataStream::ChunkData> chunk_data; | |
85 }; | |
86 | |
72 // Called by the completion callback of the document's URLLoader. | 87 // Called by the completion callback of the document's URLLoader. |
73 void DidOpen(int32_t result); | 88 void DidOpenPartial(int32_t result); |
74 // Call to read data from the document's URLLoader. | 89 // Call to read data from the document's URLLoader. |
75 void ReadMore(); | 90 void ReadMore(); |
76 // Called by the completion callback of the document's URLLoader. | 91 // Called by the completion callback of the document's URLLoader. |
77 void DidRead(int32_t result); | 92 void DidRead(int32_t result); |
78 | 93 |
79 // Called when we detect that partial document load is possible. | 94 bool ShouldCancelLoading() const; |
80 void LoadPartialDocument(); | 95 void ContinueDownload(); |
81 // Called when we have to load full document. | 96 // Called when we complete server request. |
82 void LoadFullDocument(); | |
83 // Download pending requests. | |
84 void DownloadPendingRequests(); | |
85 // Remove completed ranges. | |
86 void RemoveCompletedRanges(); | |
87 // Returns true if we are already in progress satisfying the request, or just | |
88 // about ready to start. This helps us avoid expensive jumping around, and | |
89 // even worse leaving tiny gaps in the byte stream that might have to be | |
90 // filled later. | |
91 bool SatisfyingRequest(size_t pos, size_t size) const; | |
92 // Called when we complete server request and read all data from it. | |
93 void ReadComplete(); | 97 void ReadComplete(); |
94 // Creates request to download size byte of data data starting from position. | |
95 pp::URLRequestInfo GetRequest(uint32_t position, uint32_t size) const; | |
96 // Updates the rendering by the Client. | |
97 void UpdateRendering(); | |
98 | 98 |
99 // Document below size will be downloaded in one chunk. | 99 bool SaveChunkData(char* input, uint32_t input_size); |
100 static const uint32_t kMinFileSize = 64 * 1024; | |
101 // Number was chosen in crbug.com/78264#c8 | |
102 enum { kDefaultRequestSize = 65536 }; | |
103 | 100 |
104 Client* const client_; | 101 Client* const client_; |
105 std::string url_; | 102 std::string url_; |
106 pp::URLLoader loader_; | 103 std::unique_ptr<URLLoaderWrapper> loader_; |
104 | |
107 pp::CompletionCallbackFactory<DocumentLoader> loader_factory_; | 105 pp::CompletionCallbackFactory<DocumentLoader> loader_factory_; |
108 ChunkStream chunk_stream_; | 106 |
109 bool partial_document_; | 107 DataStream chunk_stream_; |
110 bool request_pending_; | 108 bool partial_loading_enabled_ = true; |
111 typedef std::list<std::pair<size_t, size_t> > PendingRequests; | 109 bool is_partial_loader_active_ = false; |
112 PendingRequests pending_requests_; | 110 char buffer_[DataStream::kChunkSize]; |
113 // The starting position of the HTTP request currently being processed. | 111 |
114 size_t current_request_offset_; | 112 Chunk chunk_; |
115 // The size of the byte range the current HTTP request must download before | 113 RangeSet pending_requests_; |
116 // being cancelled. | |
117 size_t current_request_size_; | |
118 // The actual byte range size of the current HTTP request. This may be larger | |
119 // than |current_request_size_| and the request may be cancelled before | |
120 // reaching |current_request_offset_| + |current_request_extended_size_|. | |
121 size_t current_request_extended_size_; | |
122 char buffer_[kDefaultRequestSize]; | |
123 uint32_t current_pos_; | |
124 uint32_t current_chunk_size_; | |
125 uint32_t current_chunk_read_; | |
126 uint32_t document_size_; | |
127 bool header_request_; | |
128 bool is_multipart_; | |
129 std::string multipart_boundary_; | |
130 uint32_t requests_count_; | |
131 std::vector<std::vector<unsigned char> > chunk_buffer_; | |
132 }; | 114 }; |
133 | 115 |
134 } // namespace chrome_pdf | 116 } // namespace chrome_pdf |
135 | 117 |
136 #endif // PDF_DOCUMENT_LOADER_H_ | 118 #endif // PDF_DOCUMENT_LOADER_H_ |
OLD | NEW |