X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fnet%2Fbase%2Fsdch_dictionary_fetcher.h;h=f70d56a5ccb03f894fe3f1f34da025c88448fda9;hb=3545e9f2671f595d2a2f3ee75ca0393b01e35ef6;hp=b657b8f80c38900a889e0065a0dd410a1ef6c88b;hpb=7d210d4c7e9ba36e635eabc5b5780495f8a63292;p=platform%2Fframework%2Fweb%2Fcrosswalk.git diff --git a/src/net/base/sdch_dictionary_fetcher.h b/src/net/base/sdch_dictionary_fetcher.h index b657b8f..f70d56a 100644 --- a/src/net/base/sdch_dictionary_fetcher.h +++ b/src/net/base/sdch_dictionary_fetcher.h @@ -2,9 +2,11 @@ // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. -// Support modularity by calling to load a new SDCH filter dictionary. -// Note that this sort of calling can't be done in the /net directory, as it has -// no concept of the HTTP cache (which is only visible at the browser level). +// TODO(rdsmith): This class needs to be moved out to the net/ embedder and +// hooked into whatever mechanisms the embedder uses for authentication. +// Specifically, this class needs methods overriding +// URLRequest::Delegate::{OnAuthRequired,OnCertificateRequested} and can't +// implement them at the net/ layer. #ifndef NET_BASE_SDCH_DICTIONARY_FETCHER_H_ #define NET_BASE_SDCH_DICTIONARY_FETCHER_H_ @@ -18,66 +20,75 @@ #include "base/threading/non_thread_safe.h" #include "net/base/sdch_manager.h" #include "net/url_request/url_fetcher_delegate.h" +#include "net/url_request/url_request.h" namespace net { -class URLFetcher; -class URLRequestContextGetter; +class URLRequest; +class URLRequestThrottlerEntryInterface; +// This class implements the SdchFetcher interface. It queues requests +// for dictionaries and dispatches them serially, implementing +// the URLRequest::Delegate interface to handle callbacks (but see above +// TODO). It tracks all requests, only attempting to fetch each dictionary +// once. class NET_EXPORT SdchDictionaryFetcher - : public URLFetcherDelegate, - public SdchFetcher, + : public SdchFetcher, + public URLRequest::Delegate, public base::NonThreadSafe { public: - // Consumer must guarantee that the SdchManager pointer outlives - // this object. The current implementation guarantees this by - // the SdchManager owning this object. - SdchDictionaryFetcher(SdchManager* manager, - URLRequestContextGetter* context); + // The consumer must guarantee that |*consumer| and |*context| outlive + // this object. + SdchDictionaryFetcher(SdchFetcher::Delegate* consumer, + URLRequestContext* context); virtual ~SdchDictionaryFetcher(); - // Implementation of SdchFetcher class. + // Implementation of SdchFetcher methods. virtual void Schedule(const GURL& dictionary_url) OVERRIDE; virtual void Cancel() OVERRIDE; - private: - // Delay in ms between Schedule and actual download. - // This leaves the URL in a queue, which is de-duped, so that there is less - // chance we'll try to load the same URL multiple times when a pile of - // page subresources (or tabs opened in parallel) all suggest the dictionary. - static const int kMsDelayFromRequestTillDownload = 100; - - // Ensure the download after the above delay. - void ScheduleDelayedRun(); - - // Make sure we're processing (or waiting for) the the arrival of the next URL - // in the |fetch_queue_|. - void StartFetching(); + // Implementation of URLRequest::Delegate methods. + virtual void OnResponseStarted(URLRequest* request) OVERRIDE; + virtual void OnReadCompleted(URLRequest* request, int bytes_read) OVERRIDE; - // Implementation of URLFetcherDelegate. Called after transmission - // completes (either successfully or with failure). - virtual void OnURLFetchComplete(const URLFetcher* source) OVERRIDE; - - SdchManager* const manager_; + private: + enum State { + STATE_NONE, + STATE_IDLE, + STATE_REQUEST_STARTED, + STATE_REQUEST_READING, + STATE_REQUEST_COMPLETE, + }; + + // State machine implementation. + int DoLoop(int rv); + int DoDispatchRequest(int rv); + int DoRequestStarted(int rv); + int DoRead(int rv); + int DoCompleteRequest(int rv); + + State next_state_; + bool in_loop_; + + SdchFetcher::Delegate* const consumer_; // A queue of URLs that are being used to download dictionaries. std::queue fetch_queue_; - // The currently outstanding URL fetch of a dicitonary. - // If this is null, then there is no outstanding request. - scoped_ptr current_fetch_; - // Always spread out the dictionary fetches, so that they don't steal - // bandwidth from the actual page load. Create delayed tasks to spread out - // the download. - base::WeakPtrFactory weak_factory_; - bool task_is_pending_; + // The request and buffer used for getting the current dictionary + // Both are null when a fetch is not in progress. + scoped_ptr current_request_; + scoped_refptr buffer_; + + // The currently accumulating dictionary. + std::string dictionary_; // Althought the SDCH spec does not preclude a server from using a single URL // to load several distinct dictionaries (by telling a client to load a // dictionary from an URL several times), current implementations seem to have // that 1-1 relationship (i.e., each URL points at a single dictionary, and // the dictionary content does not change over time, and hence is not worth - // trying to load more than once). In addition, some dictionaries prove + // trying to load more than once). In addition, some dictionaries prove // unloadable only after downloading them (because they are too large? ...or // malformed?). As a protective element, Chromium will *only* load a // dictionary at most once from a given URL (so that it doesn't waste @@ -87,9 +98,11 @@ class NET_EXPORT SdchDictionaryFetcher // TODO(jar): Try to augment the SDCH proposal to include this restiction. std::set attempted_load_; - // Store the system_url_request_context_getter to use it when we start - // fetching. - scoped_refptr context_; + // Store the URLRequestContext associated with the owning SdchManager for + // use while fetching. + URLRequestContext* context_; + + base::WeakPtrFactory weak_factory_; DISALLOW_COPY_AND_ASSIGN(SdchDictionaryFetcher); };