Move net-export thread-hopping code into NetLogFileWriter and add IO polled data.

net/log/file_net_log_observer_unittest.cc

 // Copyright 2016 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/file_net_log_observer.h"
 
 #include <math.h>
 
 #include <memory>
 #include <string>
@@ skipping 339 matching lines @@
   ASSERT_TRUE(ReadNetLogFromDisk(&root, &events));
 
   // Check that custom constant was correctly printed.
   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_P(FileNetLogObserverTest, GeneratesValidJSONWithContext) {
+TEST_P(FileNetLogObserverTest, GeneratesValidJSONWithPolledData) {
   TestClosure closure;
 
   StartObserving(nullptr, nullptr);
 
-  // Create unique context.
-  TestURLRequestContext context(true);
-  context.set_net_log(&net_log_);
-  const int kDummyParam = 75;
-  std::unique_ptr<HttpNetworkSession::Params> params(
-      new HttpNetworkSession::Params);
-  params->quic_idle_connection_timeout_seconds = kDummyParam;
-  context.set_http_network_session_params(std::move(params));
-  context.Init();
+  // Create dummy polled data
+  const char kDummyPolledDataPath[] = "dummy_path";
+  const char kDummyPolledDataString[] = "dummy_info";
+  std::unique_ptr<base::DictionaryValue> dummy_polled_data =
+      base::MakeUnique<base::DictionaryValue>();
+  dummy_polled_data->SetString(kDummyPolledDataPath, kDummyPolledDataString);
 
-  logger_->StopObserving(&context, closure.closure());
+  logger_->StopObserving(std::move(dummy_polled_data), closure.closure());
 
   closure.WaitForResult();
 
   std::unique_ptr<base::Value> root;
   base::ListValue* events;
   ASSERT_TRUE(ReadNetLogFromDisk(&root, &events));
 
   // Check that no events were written.
   ASSERT_EQ(0u, events->GetSize());
 
   // Make sure additional information is present and validate it.
   base::DictionaryValue* dict;
   ASSERT_TRUE(root->GetAsDictionary(&dict));
-  base::DictionaryValue* tab_info;
-  base::DictionaryValue* quic_info;
-  ASSERT_TRUE(dict->GetDictionary("tabInfo", &tab_info));
-  ASSERT_TRUE(tab_info->GetDictionary("quicInfo", &quic_info));
-  base::Value* timeout_value = nullptr;
-  int timeout;
-  ASSERT_TRUE(
-      quic_info->Get("idle_connection_timeout_seconds", &timeout_value));
-  ASSERT_TRUE(timeout_value->GetAsInteger(&timeout));
-  ASSERT_EQ(timeout, kDummyParam);
+  base::DictionaryValue* polled_data;
+  std::string dummy_string;
+  ASSERT_TRUE(dict->GetDictionary("polledData", &polled_data));
+  ASSERT_TRUE(polled_data->GetString(kDummyPolledDataPath, &dummy_string));
+  ASSERT_EQ(dummy_string, kDummyPolledDataString);
 }
 
-TEST_P(FileNetLogObserverTest, GeneratesValidJSONWithContextWithActiveRequest) {
+TEST_P(FileNetLogObserverTest,
+       GeneratesValidJSONWithPolledDataWithActiveRequest) {
   TestClosure closure;
 
   // Create context, start a request.
   TestURLRequestContext context(true);
   context.set_net_log(&net_log_);
   context.Init();
   TestDelegate delegate;
   delegate.set_quit_on_complete(false);
 
   // URL doesn't matter.  Requests can't fail synchronously.
   std::unique_ptr<URLRequest> request(
       context.CreateRequest(GURL("blah:blah"), IDLE, &delegate));
   request->Start();
 
   StartObserving(nullptr, &context);
 
-  logger_->StopObserving(&context, closure.closure());
+  logger_->StopObserving(net::GetNetInfo(&context, NET_INFO_ALL_SOURCES),
+                         closure.closure());
 
   closure.WaitForResult();
 
   std::unique_ptr<base::Value> root;
   base::ListValue* events;
   ASSERT_TRUE(ReadNetLogFromDisk(&root, &events));
 
   // Check that 1 event was written
   ASSERT_EQ(1u, events->GetSize());
 
   // Make sure additional information is present, but don't validate it.
   base::DictionaryValue* dict;
   ASSERT_TRUE(root->GetAsDictionary(&dict));
-  base::DictionaryValue* tab_info;
-  ASSERT_TRUE(dict->GetDictionary("tabInfo", &tab_info));
+  base::DictionaryValue* polled_data;
+  ASSERT_TRUE(dict->GetDictionary("polledData", &polled_data));
 }
 
 // Adds events concurrently from several different threads. The exact order of
 // events seen by this test is non-deterministic.
 TEST_P(FileNetLogObserverTest, AddEventsFromMultipleThreads) {
   const size_t kNumThreads = 10;
   std::vector<std::unique_ptr<base::Thread>> threads(kNumThreads);
   // Start all the threads. Waiting for them to start is to hopefuly improve
   // the odds of hitting interesting races once events start being added.
   for (size_t i = 0; i < threads.size(); ++i) {
@@ skipping 389 matching lines @@
   // Check that there are events written to all files.
   for (int i = 0; i < kTotalNumFiles; i++) {
     ASSERT_GE(GetFileSize(GetEventFilePath(i)),
               static_cast<int64_t>(kEventSize));
   }
 }
 
 }  // namespace
 
 }  // namespace net