Home | History | Annotate | Download | only in base 
      1 // Copyright (c) 2012 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 NET_BASE_CAPTURING_NET_LOG_H_
      6 #define NET_BASE_CAPTURING_NET_LOG_H_
      7 
      8 #include <string>
      9 #include <vector>
     10 
     11 #include "base/atomicops.h"
     12 #include "base/basictypes.h"
     13 #include "base/compiler_specific.h"
     14 #include "base/memory/ref_counted.h"
     15 #include "base/memory/scoped_ptr.h"
     16 #include "base/synchronization/lock.h"
     17 #include "base/time/time.h"
     18 #include "net/base/net_log.h"
     19 
     20 namespace base {
     21 class DictionaryValue;
     22 class ListValue;
     23 }
     24 
     25 namespace net {
     26 
     27 // CapturingNetLog is a NetLog which instantiates Observer that saves messages
     28 // to a bounded buffer.  It is intended for testing only, and is part of the
     29 // net_test_support project. This is provided for convinience and compatilbility
     30 // with the old unittests.
     31 class CapturingNetLog : public NetLog {
     32  public:
     33   struct CapturedEntry {
     34     CapturedEntry(EventType type,
     35                   const base::TimeTicks& time,
     36                   Source source,
     37                   EventPhase phase,
     38                   scoped_ptr<base::DictionaryValue> params);
     39     // Copy constructor needed to store in a std::vector because of the
     40     // scoped_ptr.
     41     CapturedEntry(const CapturedEntry& entry);
     42 
     43     ~CapturedEntry();
     44 
     45     // Equality operator needed to store in a std::vector because of the
     46     // scoped_ptr.
     47     CapturedEntry& operator=(const CapturedEntry& entry);
     48 
     49     // Attempt to retrieve an value of the specified type with the given name
     50     // from |params|.  Returns true on success, false on failure.  Does not
     51     // modify |value| on failure.
     52     bool GetStringValue(const std::string& name, std::string* value) const;
     53     bool GetIntegerValue(const std::string& name, int* value) const;
     54     bool GetListValue(const std::string& name, base::ListValue** value) const;
     55 
     56     // Same as GetIntegerValue, but returns the error code associated with a
     57     // log entry.
     58     bool GetNetErrorCode(int* value) const;
     59 
     60     // Returns the parameters as a JSON string, or empty string if there are no
     61     // parameters.
     62     std::string GetParamsJson() const;
     63 
     64     EventType type;
     65     base::TimeTicks time;
     66     Source source;
     67     EventPhase phase;
     68     scoped_ptr<base::DictionaryValue> params;
     69   };
     70 
     71   // Ordered set of entries that were logged.
     72   typedef std::vector<CapturedEntry> CapturedEntryList;
     73 
     74   CapturingNetLog();
     75   virtual ~CapturingNetLog();
     76 
     77   void SetLogLevel(LogLevel log_level);
     78 
     79   // Below methods are forwarded to capturing_net_log_observer_.
     80   void GetEntries(CapturedEntryList* entry_list) const;
     81   void GetEntriesForSource(Source source, CapturedEntryList* entry_list) const;
     82   size_t GetSize() const;
     83   void Clear();
     84 
     85  private:
     86   // Observer is an implementation of NetLog::ThreadSafeObserver
     87   // that saves messages to a bounded buffer. It is intended for testing only,
     88   // and is part of the net_test_support project.
     89   class Observer : public NetLog::ThreadSafeObserver {
     90    public:
     91     Observer();
     92     virtual ~Observer();
     93 
     94     // Returns the list of all entries in the log.
     95     void GetEntries(CapturedEntryList* entry_list) const;
     96 
     97     // Fills |entry_list| with all entries in the log from the specified Source.
     98     void GetEntriesForSource(Source source,
     99                              CapturedEntryList* entry_list) const;
    100 
    101     // Returns number of entries in the log.
    102     size_t GetSize() const;
    103 
    104     void Clear();
    105 
    106    private:
    107     // ThreadSafeObserver implementation:
    108     virtual void OnAddEntry(const Entry& entry) OVERRIDE;
    109 
    110     // Needs to be "mutable" so can use it in GetEntries().
    111     mutable base::Lock lock_;
    112 
    113     CapturedEntryList captured_entries_;
    114 
    115     DISALLOW_COPY_AND_ASSIGN(Observer);
    116   };
    117 
    118   Observer capturing_net_log_observer_;
    119 
    120   DISALLOW_COPY_AND_ASSIGN(CapturingNetLog);
    121 };
    122 
    123 // Helper class that exposes a similar API as BoundNetLog, but uses a
    124 // CapturingNetLog rather than the more generic NetLog.
    125 //
    126 // CapturingBoundNetLog can easily be converted to a BoundNetLog using the
    127 // bound() method.
    128 class CapturingBoundNetLog {
    129  public:
    130   CapturingBoundNetLog();
    131   ~CapturingBoundNetLog();
    132 
    133   // The returned BoundNetLog is only valid while |this| is alive.
    134   BoundNetLog bound() const { return net_log_; }
    135 
    136   // Fills |entry_list| with all entries in the log.
    137   void GetEntries(CapturingNetLog::CapturedEntryList* entry_list) const;
    138 
    139   // Fills |entry_list| with all entries in the log from the specified Source.
    140   void GetEntriesForSource(
    141       NetLog::Source source,
    142       CapturingNetLog::CapturedEntryList* entry_list) const;
    143 
    144   // Returns number of entries in the log.
    145   size_t GetSize() const;
    146 
    147   void Clear();
    148 
    149   // Sets the log level of the underlying CapturingNetLog.
    150   void SetLogLevel(NetLog::LogLevel log_level);
    151 
    152  private:
    153   CapturingNetLog capturing_net_log_;
    154   const BoundNetLog net_log_;
    155 
    156   DISALLOW_COPY_AND_ASSIGN(CapturingBoundNetLog);
    157 };
    158 
    159 }  // namespace net
    160 
    161 #endif  // NET_BASE_CAPTURING_NET_LOG_H_
    162