components/precache/core/precache_fetcher.h

   1 // Copyright 2013 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 COMPONENTS_PRECACHE_CORE_PRECACHE_FETCHER_H_
   6 #define COMPONENTS_PRECACHE_CORE_PRECACHE_FETCHER_H_
   7
   8 #include <list>
   9
  10 #include "base/basictypes.h"
  11 #include "base/memory/ref_counted.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "url/gurl.h"
  14
  15 namespace net {
  16 class URLFetcher;
  17 class URLRequestContextGetter;
  18 }
  19
  20 namespace precache {
  21
  22 // Public interface to code that fetches resources that the user is likely to
  23 // want to fetch in the future, putting them in the network stack disk cache.
  24 // Precaching is intended to be done when Chrome is not actively in use, likely
  25 // hours ahead of the time when the resources are actually needed.
  26 //
  27 // This class takes as input a prioritized list of page URLs that the user
  28 // commonly visits, referred to as starting URLs. This class interacts with a
  29 // server, sending it the list of starting URLs sequentially. For each starting
  30 // URL, the server returns a manifest of resource URLs that are good candidates
  31 // for precaching. Every resource returned is fetched, and responses are cached
  32 // as they are received. Destroying the PrecacheFetcher while it is precaching
  33 // will cancel any fetch in progress and cancel precaching.
  34 //
  35 // The URLs of the server-side component must be specified in order for the
  36 // PrecacheFetcher to work. This includes the URL that the precache
  37 // configuration settings are fetched from and the prefix of URLs where precache
  38 // manifests are fetched from. These can be set by using command line switches
  39 // or by providing default values.
  40 //
  41 // Sample interaction:
  42 //
  43 // class MyPrecacheFetcherDelegate : public PrecacheFetcher::PrecacheDelegate {
  44 //  public:
  45 //   void PrecacheResourcesForTopURLs(
  46 //       net::URLRequestContextGetter* request_context,
  47 //       const std::list<GURL>& top_urls) {
  48 //     fetcher_.reset(new PrecacheFetcher(request_context, top_urls, this));
  49 //     fetcher_->Start();
  50 //   }
  51 //
  52 //   virtual void OnDone() {
  53 //     // Do something when precaching is done.
  54 //   }
  55 //
  56 //  private:
  57 //   scoped_ptr<PrecacheFetcher> fetcher_;
  58 // };
  59 class PrecacheFetcher {
  60  public:
  61   class PrecacheDelegate {
  62    public:
  63     // Called when the fetching of resources has finished, whether the resources
  64     // were fetched or not. If the PrecacheFetcher is destroyed before OnDone is
  65     // called, then precaching will be canceled and OnDone will not be called.
  66     virtual void OnDone() = 0;
  67   };
  68
  69   // Constructs a new PrecacheFetcher. The |starting_urls| parameter is a
  70   // prioritized list of page URLs that the user commonly visits. These URLs are
  71   // used by a server side component to construct a list of resource URLs that
  72   // the user is likely to fetch.
  73   PrecacheFetcher(const std::list<GURL>& starting_urls,
  74                   net::URLRequestContextGetter* request_context,
  75                   PrecacheDelegate* precache_delegate);
  76
  77   virtual ~PrecacheFetcher();
  78
  79   // Starts fetching resources to precache. URLs are fetched sequentially. Can
  80   // be called from any thread. Start should only be called once on a
  81   // PrecacheFetcher instance.
  82   void Start();
  83
  84  private:
  85   class Fetcher;
  86
  87   // Fetches the next resource or manifest URL, if any remain. Fetching is done
  88   // sequentially and depth-first: all resources are fetched for a manifest
  89   // before the next manifest is fetched. This is done to limit the length of
  90   // the |resource_urls_to_fetch_| list, reducing the memory usage.
  91   void StartNextFetch();
  92
  93   // Called when the precache configuration settings have been fetched.
  94   // Determines the list of manifest URLs to fetch according to the list of
  95   // |starting_urls_| and information from the precache configuration settings.
  96   // If the fetch of the configuration settings fails, then precaching ends.
  97   void OnConfigFetchComplete(const net::URLFetcher& source);
  98
  99   // Called when a precache manifest has been fetched. Builds the list of
 100   // resource URLs to fetch according to the URLs in the manifest. If the fetch
 101   // of a manifest fails, then it skips to the next manifest.
 102   void OnManifestFetchComplete(const net::URLFetcher& source);
 103
 104   // Called when a resource has been fetched.
 105   void OnResourceFetchComplete(const net::URLFetcher& source);
 106
 107   // The prioritized list of starting URLs that the server will pick resource
 108   // URLs to be precached for.
 109   const std::list<GURL> starting_urls_;
 110
 111   // The request context used when fetching URLs.
 112   scoped_refptr<net::URLRequestContextGetter> request_context_;
 113
 114   // Non-owning pointer. Should not be NULL.
 115   PrecacheDelegate* precache_delegate_;
 116
 117   scoped_ptr<Fetcher> fetcher_;
 118
 119   std::list<GURL> manifest_urls_to_fetch_;
 120   std::list<GURL> resource_urls_to_fetch_;
 121
 122   DISALLOW_COPY_AND_ASSIGN(PrecacheFetcher);
 123 };
 124
 125 }  // namespace precache
 126
 127 #endif  // COMPONENTS_PRECACHE_CORE_PRECACHE_FETCHER_H_