net/url_request/sdch_dictionary_fetcher.h

   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_