1// Copyright (c) 2011 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.
5// A RendererNetPredictor instance is maintained for each RenderThread.
6// URL strings are typically added to the embedded queue during rendering.
7// The first addition to the queue (transitioning from empty to having
8// some names) causes a processing task to be added to the Renderer Thread.
9// The processing task gathers all buffered names, and send them via IPC
10// to the browser, so that DNS lookups can be performed before the user attempts
11// to traverse a link.
12// This class removed some duplicates, and discards numeric IP addresss
13// (which wouldn't looked up in DNS anyway).
14// To limit the time during the processing task (and avoid stalling the Render
15// thread), several limits are placed on how much of the queue to process.
16// If the processing task is not able to completely empty the queue, it
17// schedules a future continuation of the task, and keeps the map of already
18// sent names.  If the entire queue is processed, then the list of "sent names"
19// is cleared so that future gatherings might again pass along the same names.
24#include <map>
25#include <string>
27#include "base/basictypes.h"
28#include "base/memory/weak_ptr.h"
29#include "chrome/renderer/net/predictor_queue.h"
31class RendererNetPredictor {
32 public:
33  RendererNetPredictor();
34  ~RendererNetPredictor();
36  // Push a name into the queue to be resolved.
37  void Resolve(const char* name, size_t length);
39  // SubmitHosts processes the buffered names, and submits them for DNS
40  // prefetching.
41  // Note that browser process may decide which names should be looked up (to
42  // pre-warm the cache) based on what has been (or not been) looked up
43  // recently.
44  // If sending for DNS lookup is incomplete (queue is not empty, or not all
45  // names in map are sent, or ...) then a task to continue processing is
46  // sent to our thread loop.
47  void SubmitHostnames();
49  // The following is private, but exposed for testing purposes only.
50  static bool is_numeric_ip(const char* name, size_t length);
52 private:
53  // ExtractBufferedNames pulls names from queue into the map, reducing or
54  // eliminating a waiting queue.
55  // The size_goal argument can be used to reduce the amount of
56  // processing done in this method, and can leave some data
57  // in the buffer under some circumstances.
58  // If size_goal is zero, then extraction proceeds until
59  // the queue is empty.  If size goal is positive, then
60  // extraction continues until the domain_map_ contains
61  // at least the specified number of names, or the buffer is empty.
62  void ExtractBufferedNames(size_t size_goal = 0);
64  // DnsPrefetchNames does not check the buffer, and just sends names
65  // that are already collected in the domain_map_ for DNS lookup.
66  // If max_count is zero, then all available names are sent; and
67  // if positive, then at most max_count names will be sent.
68  void DnsPrefetchNames(size_t max_count = 0);
70  // Reset() restores initial state provided after construction.
71  // This discards ALL queue entries, and map entries.
72  void Reset();
74  // We use c_string_queue_ to hold lists of names supplied typically) by the
75  // renderer.  It queues the names, at minimal cost to the renderer's thread,
76  // and allows this class to process them when time permits (in a later task).
77  DnsQueue c_string_queue_;
80  // domain_map_ contains (for each domain) one of the next two constants,
81  // depending on whether we have asked the browser process to do the actual
82  // DNS lookup.
83  static const int kLookupRequested = 0x1;
84  static const int kPending = 0x0;
85  typedef std::map<std::string, int> DomainUseMap;
86  DomainUseMap domain_map_;
88  // Cache a tally of the count of names that haven't yet been sent
89  // for DNS pre-fetching.  Note that we *could* recalculate this
90  // count by iterating over domain_map_, looking for even values.
91  size_t new_name_count_;
93  // We have some metrics to examine performance.  We might use
94  // these metrics to modify buffer counts etc. some day.
95  int buffer_full_discard_count_;
96  int numeric_ip_discard_count_;
98  base::WeakPtrFactory<RendererNetPredictor> weak_factory_;
100  DISALLOW_COPY_AND_ASSIGN(RendererNetPredictor);
101};  // class RendererNetPredictor