Skip to content

GitLab

T
tangled
Commit f98299ef authored by Eric Roman's avatar Eric Roman Committed by Commit Bot
Browse files
Options

Delete WriteToFileNetLogObserver. 

It is no longer needed as consumers of WriteToFileNetLogObserver have
been switched over to FileNetLogObserver.

Bug: 716570
Change-Id: Ia70e04aebc8560f2799a84c8c691538c5beb5db5
Reviewed-on: https://chromium-review.googlesource.com/565450
Commit-Queue: Eric Roman <eroman@chromium.org>
Reviewed-by: default avatarMatt Menke <mmenke@chromium.org>
Cr-Commit-Position: refs/heads/master@{#486259}
parent da0d3ffe
Hide whitespace changes
Inline Side-by-side
Showing with 3 additions and 455 deletions
chrome/browser/ui/webui/net_internals/net_internals_ui.cc
View file @ f98299ef
...@@ -72,7 +72,6 @@ ...@@ -72,7 +72,6 @@
#include "net/log/net_log_capture_mode.h" #include "net/log/net_log_capture_mode.h"
#include "net/log/net_log_entry.h" #include "net/log/net_log_entry.h"
#include "net/log/net_log_util.h" #include "net/log/net_log_util.h"
#include "net/log/write_to_file_net_log_observer.h"
#include "net/proxy/proxy_service.h" #include "net/proxy/proxy_service.h"
#include "net/url_request/url_request_context.h" #include "net/url_request/url_request_context.h"
#include "net/url_request/url_request_context_getter.h" #include "net/url_request/url_request_context_getter.h"
......
net/BUILD.gn
View file @ f98299ef
...@@ -994,8 +994,6 @@ component("net") { ...@@ -994,8 +994,6 @@ component("net") {
"log/net_log_util.h", "log/net_log_util.h",
"log/trace_net_log_observer.cc", "log/trace_net_log_observer.cc",
"log/trace_net_log_observer.h", "log/trace_net_log_observer.h",
"log/write_to_file_net_log_observer.cc",
"log/write_to_file_net_log_observer.h",
"nqe/cached_network_quality.cc", "nqe/cached_network_quality.cc",
"nqe/cached_network_quality.h", "nqe/cached_network_quality.h",
"nqe/effective_connection_type.cc", "nqe/effective_connection_type.cc",
...@@ -4821,7 +4819,6 @@ test("net_unittests") { ...@@ -4821,7 +4819,6 @@ test("net_unittests") {
"log/net_log_unittest.cc", "log/net_log_unittest.cc",
"log/net_log_util_unittest.cc", "log/net_log_util_unittest.cc",
"log/trace_net_log_observer_unittest.cc", "log/trace_net_log_observer_unittest.cc",
"log/write_to_file_net_log_observer_unittest.cc",
"nqe/effective_connection_type_unittest.cc", "nqe/effective_connection_type_unittest.cc",
"nqe/event_creator_unittest.cc", "nqe/event_creator_unittest.cc",
"nqe/network_qualities_prefs_manager_unittest.cc", "nqe/network_qualities_prefs_manager_unittest.cc",
......
net/log/net_log_util.cc
View file @ f98299ef
...@@ -303,8 +303,9 @@ std::unique_ptr<base::DictionaryValue> GetNetConstants() { ...@@ -303,8 +303,9 @@ std::unique_ptr<base::DictionaryValue> GetNetConstants() {
base::Int64ToString(tick_to_unix_time_ms)); base::Int64ToString(tick_to_unix_time_ms));
} }
// "clientInfo" key is required for some WriteToFileNetLogObserver log // TODO(eroman): Is this needed?
// readers. Provide a default empty value for compatibility. // "clientInfo" key is required for some log readers. Provide a default empty
// value for compatibility.
constants_dict->Set("clientInfo", base::MakeUnique<base::DictionaryValue>()); constants_dict->Set("clientInfo", base::MakeUnique<base::DictionaryValue>());
// Add a list of active field experiments. // Add a list of active field experiments.
......
net/log/write_to_file_net_log_observer.cc deleted 100644 → 0
View file @ da0d3ffe
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/log/write_to_file_net_log_observer.h"
#include <stdio.h>
#include <memory>
#include <set>
#include <utility>
#include "base/json/json_writer.h"
#include "base/logging.h"
#include "base/values.h"
#include "net/log/net_log_entry.h"
#include "net/log/net_log_util.h"
#include "net/url_request/url_request_context.h"
namespace net {
WriteToFileNetLogObserver::WriteToFileNetLogObserver()
: capture_mode_(NetLogCaptureMode::Default()), added_events_(false) {
}
WriteToFileNetLogObserver::~WriteToFileNetLogObserver() {
}
void WriteToFileNetLogObserver::set_capture_mode(
NetLogCaptureMode capture_mode) {
DCHECK(!net_log());
capture_mode_ = capture_mode;
}
void WriteToFileNetLogObserver::StartObserving(
NetLog* net_log,
base::ScopedFILE file,
base::Value* constants,
URLRequestContext* url_request_context) {
DCHECK(file.get());
file_ = std::move(file);
added_events_ = false;
// Write constants to the output file. This allows loading files that have
// different source and event types, as they may be added and removed
// between Chrome versions.
std::string json;
if (constants)
base::JSONWriter::Write(*constants, &json);
else
base::JSONWriter::Write(*GetNetConstants(), &json);
fprintf(file_.get(), "{\"constants\": %s,\n", json.c_str());
// Start events array. It's closed in StopObserving().
fprintf(file_.get(), "\"events\": [\n");
// Add events for in progress requests if a context is given.
if (url_request_context) {
url_request_context->AssertCalledOnValidThread();
std::set<URLRequestContext*> contexts;
contexts.insert(url_request_context);
CreateNetLogEntriesForActiveObjects(contexts, this);
}
net_log->DeprecatedAddObserver(this, capture_mode_);
}
void WriteToFileNetLogObserver::StopObserving(
URLRequestContext* url_request_context) {
net_log()->DeprecatedRemoveObserver(this);
// End events array.
fprintf(file_.get(), "]");
// Write state of the URLRequestContext when logging stopped.
if (url_request_context) {
url_request_context->AssertCalledOnValidThread();
std::string json;
base::JSONWriter::Write(
*GetNetInfo(url_request_context, NET_INFO_ALL_SOURCES), &json);
fprintf(file_.get(), ",\"tabInfo\": %s\n", json.c_str());
}
fprintf(file_.get(), "}");
file_.reset();
}
void WriteToFileNetLogObserver::OnAddEntry(const NetLogEntry& entry) {
// Add a comma and newline for every event but the first. Newlines are needed
// so can load partial log files by just ignoring the last line. For this to
// work, lines cannot be pretty printed.
std::unique_ptr<base::Value> value(entry.ToValue());
std::string json;
base::JSONWriter::Write(*value, &json);
fprintf(file_.get(), "%s%s", (added_events_ ? ",\n" : ""), json.c_str());
added_events_ = true;
}
} // namespace net
net/log/write_to_file_net_log_observer.h deleted 100644 → 0
View file @ da0d3ffe
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef NET_LOG_WRITE_TO_FILE_NET_LOG_OBSERVER_H_
#define NET_LOG_WRITE_TO_FILE_NET_LOG_OBSERVER_H_
#include <stdio.h>
#include "base/files/scoped_file.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "net/base/net_export.h"
#include "net/log/net_log.h"
namespace base {
class Value;
}
namespace net {
class URLRequestContext;
// WriteToFileNetLogObserver watches the NetLog event stream, and sends all
// entries to a file specified on creation.
//
// The text file will contain a single JSON object.
class NET_EXPORT WriteToFileNetLogObserver : public NetLog::ThreadSafeObserver {
public:
WriteToFileNetLogObserver();
~WriteToFileNetLogObserver() override;
// Sets the capture mode to log at. Must be called before StartObserving.
void set_capture_mode(NetLogCaptureMode capture_mode);
// Starts observing |net_log| and writes output to |file|. Must not already
// be watching a NetLog.
//
// |file| must be a non-NULL empty file that's open for writing.
//
// |constants| is an optional legend for decoding constant values used in the
// log. It should generally be a modified version of GetNetConstants(). If
// not present, the output of GetNetConstants() will be used.
//
// |url_request_context| is an optional URLRequestContext that will be used to
// pre-populate the log with information about in-progress events.
// If the context is non-NULL, this must be called on the context's thread.
void StartObserving(NetLog* net_log,
base::ScopedFILE file,
base::Value* constants,
URLRequestContext* url_request_context);
// Stops observing net_log(). Must already be watching. Must be called
// before destruction of the WriteToFileNetLogObserver and the NetLog.
//
// |url_request_context| is an optional argument used to added additional
// network stack state to the log. If the context is non-NULL, this must be
// called on the context's thread.
void StopObserving(URLRequestContext* url_request_context);
// net::NetLog::ThreadSafeObserver implementation:
void OnAddEntry(const NetLogEntry& entry) override;
private:
// ----------------
// Thread safety
// ----------------
//
// NetLog observers are invoked on arbitrary threads, however are notified of
// events in a serial fashion (the NetLog lock is held while dispatching
// events to observers).
//
// As a result, the following variables do NOT need to be protected by a lock,
// as parallel execution of OnAddEntry() is not possible.
//
// However any access to them outside of OnAddEntry() should be either
// before the call to NetLog::DeprecatedAddObserver() or after the call to
// NetLog::DeprecatedRemoveObserver().
base::ScopedFILE file_;
// The capture mode to log at.
NetLogCaptureMode capture_mode_;
// True if OnAddEntry() has been called at least once.
bool added_events_;
DISALLOW_COPY_AND_ASSIGN(WriteToFileNetLogObserver);
};
} // namespace net
#endif // NET_LOG_WRITE_TO_FILE_NET_LOG_OBSERVER_H_
net/log/write_to_file_net_log_observer_unittest.cc deleted 100644 → 0
View file @ da0d3ffe
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/log/write_to_file_net_log_observer.h"
#include <memory>
#include <utility>
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/files/scoped_file.h"
#include "base/files/scoped_temp_dir.h"
#include "base/json/json_reader.h"
#include "base/values.h"
#include "net/log/net_log.h"
#include "net/log/net_log_entry.h"
#include "net/log/net_log_event_type.h"
#include "net/log/net_log_source.h"
#include "net/log/net_log_source_type.h"
#include "net/log/net_log_util.h"
#include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
#include "net/url_request/url_request.h"
#include "net/url_request/url_request_context.h"
#include "net/url_request/url_request_test_util.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace net {
namespace {
class WriteToFileNetLogObserverTest : public testing::Test {
public:
void SetUp() override {
ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
log_path_ = temp_dir_.GetPath().AppendASCII("NetLogFile");
}
protected:
base::ScopedTempDir temp_dir_;
base::FilePath log_path_;
NetLog net_log_;
};
TEST_F(WriteToFileNetLogObserverTest, GeneratesValidJSONForNoEvents) {
// Create and destroy a logger.
base::ScopedFILE file(base::OpenFile(log_path_, "w"));
ASSERT_TRUE(file);
std::unique_ptr<WriteToFileNetLogObserver> logger(
new WriteToFileNetLogObserver());
logger->StartObserving(&net_log_, std::move(file), nullptr, nullptr);
logger->StopObserving(nullptr);
logger.reset();
std::string input;
ASSERT_TRUE(base::ReadFileToString(log_path_, &input));
base::JSONReader reader;
std::unique_ptr<base::Value> root(reader.ReadToValue(input));
ASSERT_TRUE(root) << reader.GetErrorMessage();
base::DictionaryValue* dict;
ASSERT_TRUE(root->GetAsDictionary(&dict));
base::ListValue* events;
ASSERT_TRUE(dict->GetList("events", &events));
ASSERT_EQ(0u, events->GetSize());
base::DictionaryValue* constants;
ASSERT_TRUE(dict->GetDictionary("constants", &constants));
}
TEST_F(WriteToFileNetLogObserverTest, CaptureMode) {
base::ScopedFILE file(base::OpenFile(log_path_, "w"));
ASSERT_TRUE(file);
WriteToFileNetLogObserver logger;
logger.StartObserving(&net_log_, std::move(file), nullptr, nullptr);
EXPECT_EQ(NetLogCaptureMode::Default(), logger.capture_mode());
logger.StopObserving(nullptr);
file.reset(base::OpenFile(log_path_, "w"));
ASSERT_TRUE(file);
logger.set_capture_mode(NetLogCaptureMode::IncludeCookiesAndCredentials());
logger.StartObserving(&net_log_, std::move(file), nullptr, nullptr);
EXPECT_EQ(NetLogCaptureMode::IncludeCookiesAndCredentials(),
logger.capture_mode());
logger.StopObserving(nullptr);
}
TEST_F(WriteToFileNetLogObserverTest, GeneratesValidJSONWithOneEvent) {
base::ScopedFILE file(base::OpenFile(log_path_, "w"));
ASSERT_TRUE(file);
std::unique_ptr<WriteToFileNetLogObserver> logger(
new WriteToFileNetLogObserver());
logger->StartObserving(&net_log_, std::move(file), nullptr, nullptr);
const int kDummyId = 1;
NetLogSource source(NetLogSourceType::HTTP2_SESSION, kDummyId);
NetLogEntryData entry_data(NetLogEventType::PROXY_SERVICE, source,
NetLogEventPhase::BEGIN, base::TimeTicks::Now(),
NULL);
NetLogEntry entry(&entry_data, NetLogCaptureMode::IncludeSocketBytes());
logger->OnAddEntry(entry);
logger->StopObserving(nullptr);
logger.reset();
std::string input;
ASSERT_TRUE(base::ReadFileToString(log_path_, &input));
base::JSONReader reader;
std::unique_ptr<base::Value> root(reader.ReadToValue(input));
ASSERT_TRUE(root) << reader.GetErrorMessage();
base::DictionaryValue* dict;
ASSERT_TRUE(root->GetAsDictionary(&dict));
base::ListValue* events;
ASSERT_TRUE(dict->GetList("events", &events));
ASSERT_EQ(1u, events->GetSize());
}
TEST_F(WriteToFileNetLogObserverTest, GeneratesValidJSONWithMultipleEvents) {
base::ScopedFILE file(base::OpenFile(log_path_, "w"));
ASSERT_TRUE(file);
std::unique_ptr<WriteToFileNetLogObserver> logger(
new WriteToFileNetLogObserver());
logger->StartObserving(&net_log_, std::move(file), nullptr, nullptr);
const int kDummyId = 1;
NetLogSource source(NetLogSourceType::HTTP2_SESSION, kDummyId);
NetLogEntryData entry_data(NetLogEventType::PROXY_SERVICE, source,
NetLogEventPhase::BEGIN, base::TimeTicks::Now(),
NULL);
NetLogEntry entry(&entry_data, NetLogCaptureMode::IncludeSocketBytes());
// Add the entry multiple times.
logger->OnAddEntry(entry);
logger->OnAddEntry(entry);
logger->StopObserving(nullptr);
logger.reset();
std::string input;
ASSERT_TRUE(base::ReadFileToString(log_path_, &input));
base::JSONReader reader;
std::unique_ptr<base::Value> root(reader.ReadToValue(input));
ASSERT_TRUE(root) << reader.GetErrorMessage();
base::DictionaryValue* dict;
ASSERT_TRUE(root->GetAsDictionary(&dict));
base::ListValue* events;
ASSERT_TRUE(dict->GetList("events", &events));
ASSERT_EQ(2u, events->GetSize());
}
TEST_F(WriteToFileNetLogObserverTest, CustomConstants) {
const char kConstantString[] = "awesome constant";
std::unique_ptr<base::Value> constants(new base::Value(kConstantString));
base::ScopedFILE file(base::OpenFile(log_path_, "w"));
ASSERT_TRUE(file);
std::unique_ptr<WriteToFileNetLogObserver> logger(
new WriteToFileNetLogObserver());
logger->StartObserving(&net_log_, std::move(file), constants.get(), nullptr);
logger->StopObserving(nullptr);
logger.reset();
std::string input;
ASSERT_TRUE(base::ReadFileToString(log_path_, &input));
base::JSONReader reader;
std::unique_ptr<base::Value> root(reader.ReadToValue(input));
ASSERT_TRUE(root) << reader.GetErrorMessage();
base::DictionaryValue* dict;
ASSERT_TRUE(root->GetAsDictionary(&dict));
std::string constants_string;
ASSERT_TRUE(dict->GetString("constants", &constants_string));
ASSERT_EQ(kConstantString, constants_string);
}
TEST_F(WriteToFileNetLogObserverTest, GeneratesValidJSONWithContext) {
// Create context, start a request.
TestURLRequestContext context(true);
context.set_net_log(&net_log_);
context.Init();
// Create and destroy a logger.
base::ScopedFILE file(base::OpenFile(log_path_, "w"));
ASSERT_TRUE(file);
std::unique_ptr<WriteToFileNetLogObserver> logger(
new WriteToFileNetLogObserver());
logger->StartObserving(&net_log_, std::move(file), nullptr, &context);
logger->StopObserving(&context);
logger.reset();
std::string input;
ASSERT_TRUE(base::ReadFileToString(log_path_, &input));
base::JSONReader reader;
std::unique_ptr<base::Value> root(reader.ReadToValue(input));
ASSERT_TRUE(root) << reader.GetErrorMessage();
base::DictionaryValue* dict;
ASSERT_TRUE(root->GetAsDictionary(&dict));
base::ListValue* events;
ASSERT_TRUE(dict->GetList("events", &events));
ASSERT_EQ(0u, events->GetSize());
// Make sure additional information is present, but don't validate it.
base::DictionaryValue* tab_info;
ASSERT_TRUE(dict->GetDictionary("tabInfo", &tab_info));
}
TEST_F(WriteToFileNetLogObserverTest,
GeneratesValidJSONWithContextWithActiveRequest) {
// Create context, start a request.
TestURLRequestContext context(true);
context.set_net_log(&net_log_);
context.Init();
TestDelegate delegate;
// URL doesn't matter. Requests can't fail synchronously.
std::unique_ptr<URLRequest> request(context.CreateRequest(
GURL("blah:blah"), IDLE, &delegate, TRAFFIC_ANNOTATION_FOR_TESTS));
request->Start();
// Create and destroy a logger.
base::ScopedFILE file(base::OpenFile(log_path_, "w"));
ASSERT_TRUE(file);
std::unique_ptr<WriteToFileNetLogObserver> logger(
new WriteToFileNetLogObserver());
logger->StartObserving(&net_log_, std::move(file), nullptr, &context);
logger->StopObserving(&context);
logger.reset();
std::string input;
ASSERT_TRUE(base::ReadFileToString(log_path_, &input));
base::JSONReader reader;
std::unique_ptr<base::Value> root(reader.ReadToValue(input));
ASSERT_TRUE(root) << reader.GetErrorMessage();
base::DictionaryValue* dict;
ASSERT_TRUE(root->GetAsDictionary(&dict));
base::ListValue* events;
ASSERT_TRUE(dict->GetList("events", &events));
ASSERT_EQ(1u, events->GetSize());
// Make sure additional information is present, but don't validate it.
base::DictionaryValue* tab_info;
ASSERT_TRUE(dict->GetDictionary("tabInfo", &tab_info));
}
} // namespace
} // namespace net
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment