OLD | NEW |
| (Empty) |
1 // Copyright 2014 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 // TODO(rdsmith): This class needs to delegate URLRequest::Delegate methods | |
6 // to the net/ embedder for correct implementation of authentication. | |
7 // Specifically, this class needs the embedder to provide functionality | |
8 // corresponding to | |
9 // URLRequest::Delegate::{OnAuthRequired,OnCertificateRequested}. | |
10 | |
11 #ifndef NET_URL_REQUEST_SDCH_DICTIONARY_FETCHER_H_ | |
12 #define NET_URL_REQUEST_SDCH_DICTIONARY_FETCHER_H_ | |
13 | |
14 #include <queue> | |
15 #include <set> | |
16 #include <string> | |
17 | |
18 #include "base/macros.h" | |
19 #include "base/memory/ref_counted.h" | |
20 #include "base/memory/scoped_ptr.h" | |
21 #include "base/memory/weak_ptr.h" | |
22 #include "base/threading/non_thread_safe.h" | |
23 #include "net/base/sdch_manager.h" | |
24 #include "net/url_request/url_fetcher_delegate.h" | |
25 #include "net/url_request/url_request.h" | |
26 #include "url/gurl.h" | |
27 | |
28 namespace net { | |
29 | |
30 class BoundNetLog; | |
31 class URLRequest; | |
32 class URLRequestThrottlerEntryInterface; | |
33 | |
34 // This class is used by embedder SDCH policy object to fetch | |
35 // dictionaries. It queues requests for dictionaries and dispatches | |
36 // them serially, implementing the URLRequest::Delegate interface to | |
37 // handle callbacks (but see above TODO). It tracks all requests, only | |
38 // attempting to fetch each dictionary once. | |
39 class NET_EXPORT SdchDictionaryFetcher : public URLRequest::Delegate, | |
40 public base::NonThreadSafe { | |
41 public: | |
42 typedef base::Callback<void(const std::string& dictionary_text, | |
43 const GURL& dictionary_url, | |
44 const BoundNetLog& net_log)> | |
45 OnDictionaryFetchedCallback; | |
46 | |
47 // The consumer must guarantee that |*context| outlives this object. | |
48 // |callback| will be called on successful dictionary fetch | |
49 // requested through Schedule(). |callback| will not be called | |
50 // after object destruction. | |
51 SdchDictionaryFetcher(URLRequestContext* context, | |
52 const OnDictionaryFetchedCallback& callback); | |
53 ~SdchDictionaryFetcher() override; | |
54 | |
55 // Request a new dictionary fetch. | |
56 void Schedule(const GURL& dictionary_url); | |
57 | |
58 // Cancel any in-progress requests. | |
59 void Cancel(); | |
60 | |
61 // Implementation of URLRequest::Delegate methods. | |
62 void OnResponseStarted(URLRequest* request) override; | |
63 void OnReadCompleted(URLRequest* request, int bytes_read) override; | |
64 | |
65 private: | |
66 enum State { | |
67 STATE_NONE, | |
68 STATE_SEND_REQUEST, | |
69 STATE_SEND_REQUEST_COMPLETE, | |
70 STATE_READ_BODY, | |
71 STATE_READ_BODY_COMPLETE, | |
72 STATE_REQUEST_COMPLETE, | |
73 }; | |
74 | |
75 // State machine implementation. | |
76 int DoLoop(int rv); | |
77 int DoSendRequest(int rv); | |
78 int DoSendRequestComplete(int rv); | |
79 int DoReadBody(int rv); | |
80 int DoReadBodyComplete(int rv); | |
81 int DoCompleteRequest(int rv); | |
82 | |
83 State next_state_; | |
84 bool in_loop_; | |
85 | |
86 // A queue of URLs that are being used to download dictionaries. | |
87 std::queue<GURL> fetch_queue_; | |
88 | |
89 // The request and buffer used for getting the current dictionary | |
90 // Both are null when a fetch is not in progress. | |
91 scoped_ptr<URLRequest> current_request_; | |
92 scoped_refptr<IOBuffer> buffer_; | |
93 | |
94 // The currently accumulating dictionary. | |
95 std::string dictionary_; | |
96 | |
97 // Althought the SDCH spec does not preclude a server from using a single URL | |
98 // to load several distinct dictionaries (by telling a client to load a | |
99 // dictionary from an URL several times), current implementations seem to have | |
100 // that 1-1 relationship (i.e., each URL points at a single dictionary, and | |
101 // the dictionary content does not change over time, and hence is not worth | |
102 // trying to load more than once). In addition, some dictionaries prove | |
103 // unloadable only after downloading them (because they are too large? ...or | |
104 // malformed?). As a protective element, Chromium will *only* load a | |
105 // dictionary at most once from a given URL (so that it doesn't waste | |
106 // bandwidth trying repeatedly). | |
107 // The following set lists all the dictionary URLs that we've tried to load, | |
108 // so that we won't try to load from an URL more than once. | |
109 // TODO(jar): Try to augment the SDCH proposal to include this restiction. | |
110 std::set<GURL> attempted_load_; | |
111 | |
112 // Store the URLRequestContext associated with the owning SdchManager for | |
113 // use while fetching. | |
114 URLRequestContext* const context_; | |
115 | |
116 const OnDictionaryFetchedCallback dictionary_fetched_callback_; | |
117 | |
118 base::WeakPtrFactory<SdchDictionaryFetcher> weak_factory_; | |
119 | |
120 DISALLOW_COPY_AND_ASSIGN(SdchDictionaryFetcher); | |
121 }; | |
122 | |
123 } // namespace net | |
124 | |
125 #endif // NET_URL_REQUEST_SDCH_DICTIONARY_FETCHER_H_ | |
OLD | NEW |