test_net_log.cc 3.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113
  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. #include "net/log/test_net_log.h"
  5. #include "base/synchronization/lock.h"
  6. #include "base/values.h"
  7. #include "net/log/net_log_capture_mode.h"
  8. #include "net/log/net_log_entry.h"
  9. #include "net/log/net_log_source.h"
  10. #include "net/log/net_log_source_type.h"
  11. namespace net {
  12. RecordingNetLogObserver::RecordingNetLogObserver()
  13. : RecordingNetLogObserver(NetLogCaptureMode::kIncludeSensitive) {}
  14. RecordingNetLogObserver::RecordingNetLogObserver(NetLogCaptureMode capture_mode)
  15. : RecordingNetLogObserver(NetLog::Get(), capture_mode) {}
  16. RecordingNetLogObserver::RecordingNetLogObserver(NetLog* net_log,
  17. NetLogCaptureMode capture_mode)
  18. : net_log_(net_log) {
  19. net_log_->AddObserver(this, capture_mode);
  20. }
  21. RecordingNetLogObserver::~RecordingNetLogObserver() {
  22. net_log_->RemoveObserver(this);
  23. }
  24. std::vector<NetLogEntry> RecordingNetLogObserver::GetEntries() const {
  25. base::AutoLock lock(lock_);
  26. std::vector<NetLogEntry> result;
  27. for (const auto& entry : entry_list_)
  28. result.push_back(entry.Clone());
  29. return result;
  30. }
  31. std::vector<NetLogEntry> RecordingNetLogObserver::GetEntriesForSource(
  32. NetLogSource source) const {
  33. base::AutoLock lock(lock_);
  34. std::vector<NetLogEntry> result;
  35. for (const auto& entry : entry_list_) {
  36. if (entry.source.id == source.id)
  37. result.push_back(entry.Clone());
  38. }
  39. return result;
  40. }
  41. std::vector<NetLogEntry> RecordingNetLogObserver::GetEntriesWithType(
  42. NetLogEventType type) const {
  43. base::AutoLock lock(lock_);
  44. std::vector<NetLogEntry> result;
  45. for (const auto& entry : entry_list_) {
  46. if (entry.type == type)
  47. result.push_back(entry.Clone());
  48. }
  49. return result;
  50. }
  51. std::vector<NetLogEntry> RecordingNetLogObserver::GetEntriesForSourceWithType(
  52. NetLogSource source,
  53. NetLogEventType type,
  54. NetLogEventPhase phase) const {
  55. base::AutoLock lock(lock_);
  56. std::vector<NetLogEntry> result;
  57. for (const auto& entry : entry_list_) {
  58. if (entry.source.id == source.id && entry.type == type &&
  59. entry.phase == phase) {
  60. result.push_back(entry.Clone());
  61. }
  62. }
  63. return result;
  64. }
  65. size_t RecordingNetLogObserver::GetSize() const {
  66. base::AutoLock lock(lock_);
  67. return entry_list_.size();
  68. }
  69. void RecordingNetLogObserver::Clear() {
  70. base::AutoLock lock(lock_);
  71. entry_list_.clear();
  72. }
  73. void RecordingNetLogObserver::OnAddEntry(const NetLogEntry& entry) {
  74. base::Value params = entry.params.Clone();
  75. base::RepeatingClosure add_entry_callback;
  76. {
  77. // Only need to acquire the lock when accessing class variables.
  78. base::AutoLock lock(lock_);
  79. entry_list_.emplace_back(entry.type, entry.source, entry.phase, entry.time,
  80. std::move(params));
  81. add_entry_callback = add_entry_callback_;
  82. }
  83. if (!add_entry_callback.is_null())
  84. add_entry_callback.Run();
  85. }
  86. void RecordingNetLogObserver::SetObserverCaptureMode(
  87. NetLogCaptureMode capture_mode) {
  88. net_log_->RemoveObserver(this);
  89. net_log_->AddObserver(this, capture_mode);
  90. }
  91. void RecordingNetLogObserver::SetThreadsafeAddEntryCallback(
  92. base::RepeatingClosure add_entry_callback) {
  93. base::AutoLock lock(lock_);
  94. add_entry_callback_ = add_entry_callback;
  95. }
  96. } // namespace net