Extract common code in BoundedFileNetLogObserverTest for reading NetLog.

net/log/bounded_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/bounded_file_net_log_observer.h"
 
 #include <math.h>
 
 #include <memory>
 #include <string>
 #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/json/json_writer.h"
 #include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "net/base/test_completion_callback.h"
 #include "net/log/net_log_entry.h"
 #include "net/log/net_log_event_type.h"
 #include "net/log/net_log_parameters_callback.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/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
@@ skipping 102 matching lines @@
       message = std::string(entry_size - base_entry_size - id.size() + 1, 'x');
       callback = NetLog::StringCallback("message", &message);
       NetLogEntryData entry_data(NetLogEventType::PAC_JAVASCRIPT_ERROR, source,
                                  NetLogEventPhase::BEGIN,
                                  base::TimeTicks::Now(), &callback);
       NetLogEntry entry(&entry_data, NetLogCaptureMode::IncludeSocketBytes());
       logger_->OnAddEntry(entry);
     }
   }
 
+  // Reads the NetLog data that was written to disk to |root|. |events|
+  // points at the "events" section.
+  ::testing::AssertionResult ReadNetLogFromDisk(
+      std::unique_ptr<base::Value>* root,
+      base::ListValue** events) {
+    std::string input;
+    AddAllFiles(&input);
+    if (input.empty()) {
+      return ::testing::AssertionFailure() << "input is empty";
+    }
+
+    base::JSONReader reader;
+    *root = reader.ReadToValue(input);
+    if (!*root) {
+      return ::testing::AssertionFailure() << reader.GetErrorMessage();
+    }
+
+    base::DictionaryValue* dict;
+    if (!(*root)->GetAsDictionary(&dict)) {
+      return ::testing::AssertionFailure() << "Not a dictionary";
+    }
+
+    if (!dict->GetList("events", events)) {
+      return ::testing::AssertionFailure() << "No events list";
+    }
+
+    return ::testing::AssertionSuccess();
+  }
+
  protected:
   base::FilePath log_path_;
   NetLog net_log_;
   std::unique_ptr<base::Thread> file_thread_;
   std::unique_ptr<BoundedFileNetLogObserver> logger_;
 
  private:
   base::ScopedTempDir temp_dir_;
 };
 
@@ skipping 17 matching lines @@
 
 TEST_F(BoundedFileNetLogObserverTest, GeneratesValidJSONForNoEvents) {
   TestClosure closure;
 
   logger_->StartObserving(&net_log_, log_path_, nullptr, nullptr,
                           kLargeFileSize, kTotalNumFiles);
   logger_->StopObserving(nullptr, closure.closure());
 
   closure.WaitForResult();
 
-  std::string input;
-  AddAllFiles(&input);
-  ASSERT_FALSE(input.empty());
-
-  // Parse JSON
-  base::JSONReader reader;
-  std::unique_ptr<base::Value> root(reader.Read(input));
-  ASSERT_TRUE(root) << reader.GetErrorMessage();
+  std::unique_ptr<base::Value> root;
+  base::ListValue* events;
+  ASSERT_TRUE(ReadNetLogFromDisk(&root, &events));
 
   // Check that there are no events
-  base::DictionaryValue* dict;
-  ASSERT_TRUE(root->GetAsDictionary(&dict));
-  base::ListValue* events;
-  ASSERT_TRUE(dict->GetList("events", &events));
   ASSERT_EQ(0u, events->GetSize());
 
   // Check that constants are printed
+  base::DictionaryValue* dict;
+  ASSERT_TRUE(root->GetAsDictionary(&dict));
   base::DictionaryValue* constants;
   ASSERT_TRUE(dict->GetDictionary("constants", &constants));
 }
 
 // Checks that capture_mode_ defaults correctly when set_capture_mode is not
 // called, and that |capture_mode_| is changed when set_capture_mode is called.
 TEST_F(BoundedFileNetLogObserverTest, SetsCaptureMode) {
   TestClosure default_closure;
 
   logger_->StartObserving(&net_log_, log_path_, nullptr, nullptr,
@@ skipping 27 matching lines @@
   logger_->StartObserving(&net_log_, log_path_, nullptr, nullptr,
                           kLargeFileSize, kTotalNumFiles);
 
   // Send dummy event.
   AddEntries(1, kDummyEventSize);
 
   logger_->StopObserving(nullptr, closure.closure());
 
   closure.WaitForResult();
 
-  std::string input;
-  AddAllFiles(&input);
-  ASSERT_FALSE(input.empty());
-
-  // Parse input.
-  base::JSONReader reader;
-  std::unique_ptr<base::Value> root(reader.ReadToValue(input));
-
-  ASSERT_TRUE(root) << reader.GetErrorMessage();
+  std::unique_ptr<base::Value> root;
+  base::ListValue* events;
+  ASSERT_TRUE(ReadNetLogFromDisk(&root, &events));
 
   // Check that there is 1 event written.
-  base::DictionaryValue* dict;
-  ASSERT_TRUE(root->GetAsDictionary(&dict));
-  base::ListValue* events;
-  ASSERT_TRUE(dict->GetList("events", &events));
   ASSERT_EQ(1u, events->GetSize());
 }
 
 TEST_F(BoundedFileNetLogObserverTest, GeneratesValidJSONWithMultipleEvents) {
   const int kTotalFileSize = 250000;
   TestClosure closure;
 
   logger_->StartObserving(&net_log_, log_path_, nullptr, nullptr,
                           kTotalFileSize, kTotalNumFiles);
 
   AddEntries(2, kDummyEventSize);
 
   logger_->StopObserving(nullptr, closure.closure());
 
   closure.WaitForResult();
 
-  std::string input;
-  AddAllFiles(&input);
-  ASSERT_FALSE(input.empty());
-
-  base::JSONReader reader;
-  std::unique_ptr<base::Value> root(reader.ReadToValue(input));
-  ASSERT_TRUE(root) << reader.GetErrorMessage();
+  std::unique_ptr<base::Value> root;
+  base::ListValue* events;
+  ASSERT_TRUE(ReadNetLogFromDisk(&root, &events));
 
   // Check that 2 events are written.
-  base::DictionaryValue* dict;
-  ASSERT_TRUE(root->GetAsDictionary(&dict));
-  base::ListValue* events;
-  ASSERT_TRUE(dict->GetList("events", &events));
   ASSERT_EQ(2u, events->GetSize());
 }
 
 // Sends enough events to the observer to completely fill one file, but not
 // write any events to an additional file. Checks the file bounds.
 TEST_F(BoundedFileNetLogObserverTest, EqualToOneFile) {
   // The total size of the events is equal to the size of one file.
   // |kNumEvents| * |kEventSize| = |kTotalFileSize| / |kTotalNumEvents|
   const int kTotalFileSize = 5000;
   const int kNumEvents = 2;
   const int kEventSize = 250;
   TestClosure closure;
 
   logger_->StartObserving(&net_log_, log_path_, nullptr, nullptr,
                           kTotalFileSize, kTotalNumFiles);
 
   AddEntries(kNumEvents, kEventSize);
   logger_->StopObserving(nullptr, closure.closure());
 
   closure.WaitForResult();
 
-  std::string input;
-  AddAllFiles(&input);
-  ASSERT_FALSE(input.empty());
-
-  base::JSONReader reader;
-  std::unique_ptr<base::Value> root(reader.ReadToValue(input));
-  ASSERT_TRUE(root) << reader.GetErrorMessage();
+  std::unique_ptr<base::Value> root;
+  base::ListValue* events;
+  ASSERT_TRUE(ReadNetLogFromDisk(&root, &events));
 
   // Check that the correct number of events were written.
-  base::DictionaryValue* dict;
-  ASSERT_TRUE(root->GetAsDictionary(&dict));
-  base::ListValue* events;
-  ASSERT_TRUE(dict->GetList("events", &events));
   ASSERT_EQ(static_cast<size_t>(kNumEvents), events->GetSize());
 
   // Check that the last event in array is the last event written.
   base::Value* last_event = nullptr;
   ASSERT_TRUE(events->Get(events->GetSize() - 1, &last_event));
+  base::DictionaryValue* dict;
   last_event->GetAsDictionary(&dict);
   base::Value* id_value = nullptr;
   ASSERT_TRUE(dict->Get("source.id", &id_value));
   int id;
   ASSERT_TRUE(id_value->GetAsInteger(&id));
   ASSERT_EQ(kNumEvents - 1, id);
 
   // Check that events have been written to the first file.
   base::ScopedFILE first_file(base::OpenFile(
       log_path_.AppendASCII("event_file_" + std::to_string(0) + ".json"),
@@ skipping 24 matching lines @@
 
   logger_->StartObserving(&net_log_, log_path_, nullptr, nullptr,
                           kTotalFileSize, kTotalNumFiles);
 
   AddEntries(kNumEvents, kEventSize);
 
   logger_->StopObserving(nullptr, closure.closure());
 
   closure.WaitForResult();
 
-  std::string input;
-  AddAllFiles(&input);
-  ASSERT_FALSE(input.empty());
-
-  base::JSONReader reader;
-  std::unique_ptr<base::Value> root(reader.ReadToValue(input));
-  ASSERT_TRUE(root) << reader.GetErrorMessage();
+  std::unique_ptr<base::Value> root;
+  base::ListValue* events;
+  ASSERT_TRUE(ReadNetLogFromDisk(&root, &events));
 
   // Check that the correct number of events were written.
-  base::DictionaryValue* dict;
-  ASSERT_TRUE(root->GetAsDictionary(&dict));
-  base::ListValue* events;
-  ASSERT_TRUE(dict->GetList("events", &events));
   ASSERT_EQ(static_cast<size_t>(kNumEvents), events->GetSize());
 
   // Check that the last event in array is the last event written.
   base::Value* last_event = nullptr;
   ASSERT_TRUE(events->Get(events->GetSize() - 1, &last_event));
+  base::DictionaryValue* dict;
   last_event->GetAsDictionary(&dict);
   base::Value* id_value = nullptr;
   ASSERT_TRUE(dict->Get("source.id", &id_value));
   int id;
   ASSERT_TRUE(id_value->GetAsInteger(&id));
   ASSERT_EQ(kNumEvents - 1, id);
 
   // Check that all event files except the first two do not exist.
   for (int i = 2; i < kTotalNumFiles; i++) {
     ASSERT_FALSE(base::PathExists(
@@ skipping 12 matching lines @@
 
   logger_->StartObserving(&net_log_, log_path_, nullptr, nullptr,
                           kTotalFileSize, kTotalNumFiles);
 
   AddEntries(kNumEvents, kEventSize);
 
   logger_->StopObserving(nullptr, closure.closure());
 
   closure.WaitForResult();
 
-  std::string input;
-  AddAllFiles(&input);
-  ASSERT_FALSE(input.empty());
-
-  base::JSONReader reader;
-  std::unique_ptr<base::Value> root(reader.ReadToValue(input));
-  ASSERT_TRUE(root) << reader.GetErrorMessage();
+  std::unique_ptr<base::Value> root;
+  base::ListValue* events;
+  ASSERT_TRUE(ReadNetLogFromDisk(&root, &events));
 
   // Check that the correct number of events were written.
-  base::DictionaryValue* dict;
-  ASSERT_TRUE(root->GetAsDictionary(&dict));
-  base::ListValue* events;
-  ASSERT_TRUE(dict->GetList("events", &events));
   ASSERT_EQ(static_cast<size_t>(kNumEvents), events->GetSize());
 
   // Check that the last event in array is the last event written.
   base::Value* last_event = nullptr;
   ASSERT_TRUE(events->Get(events->GetSize() - 1, &last_event));
+  base::DictionaryValue* dict;
   last_event->GetAsDictionary(&dict);
   base::Value* id_value = nullptr;
   ASSERT_TRUE(dict->Get("source.id", &id_value));
   int id;
   ASSERT_TRUE(id_value->GetAsInteger(&id));
   ASSERT_EQ(kNumEvents - 1, id);
 
   // Check that the first two event files are full.
   for (int i = 0; i < (kNumEvents * kEventSize) /
                           ((kTotalFileSize - 1) / kTotalNumFiles + 1);
@@ skipping 27 matching lines @@
 
   logger_->StartObserving(&net_log_, log_path_, nullptr, nullptr,
                           kTotalFileSize, kTotalNumFiles);
 
   AddEntries(kNumEvents, kEventSize);
 
   logger_->StopObserving(nullptr, closure.closure());
 
   closure.WaitForResult();
 
-  std::string input;
-  AddAllFiles(&input);
-  ASSERT_FALSE(input.empty());
-
-  base::JSONReader reader;
-  std::unique_ptr<base::Value> root(reader.ReadToValue(input));
-  ASSERT_TRUE(root) << reader.GetErrorMessage();
+  std::unique_ptr<base::Value> root;
+  base::ListValue* events;
+  ASSERT_TRUE(ReadNetLogFromDisk(&root, &events));
 
   // Check that the correct number of events were written.
-  base::DictionaryValue* dict;
-  ASSERT_TRUE(root->GetAsDictionary(&dict));
-  base::ListValue* events;
-  ASSERT_TRUE(dict->GetList("events", &events));
   ASSERT_EQ(static_cast<size_t>(kNumEvents), events->GetSize());
 
   // Check that the last event in array is the last event written.
   base::Value* last_event = nullptr;
   ASSERT_TRUE(events->Get(events->GetSize() - 1, &last_event));
+  base::DictionaryValue* dict;
   last_event->GetAsDictionary(&dict);
   base::Value* id_value = nullptr;
   ASSERT_TRUE(dict->Get("source.id", &id_value));
   int id;
   ASSERT_TRUE(id_value->GetAsInteger(&id));
   ASSERT_EQ(kNumEvents - 1, id);
 
   // Check that all the event files are full.
   for (int i = 0; i < kTotalNumFiles; i++) {
     base::ScopedFILE file_to_test(base::OpenFile(
@@ skipping 20 matching lines @@
 
   logger_->StartObserving(&net_log_, log_path_, nullptr, nullptr,
                           kTotalFileSize, kTotalNumFiles);
 
   AddEntries(kNumEvents, kEventSize);
 
   logger_->StopObserving(nullptr, closure.closure());
 
   closure.WaitForResult();
 
-  std::string input;
-  AddAllFiles(&input);
-  ASSERT_FALSE(input.empty());
-
-  base::JSONReader reader;
-  std::unique_ptr<base::Value> root(reader.ReadToValue(input));
-  ASSERT_TRUE(root) << reader.GetErrorMessage();
+  std::unique_ptr<base::Value> root;
+  base::ListValue* events;
+  ASSERT_TRUE(ReadNetLogFromDisk(&root, &events));
 
   // Check that the correct number of events were written.
-  base::DictionaryValue* dict;
-  ASSERT_TRUE(root->GetAsDictionary(&dict));
-  base::ListValue* events;
-  ASSERT_TRUE(dict->GetList("events", &events));
   ASSERT_EQ(
       static_cast<size_t>(kTotalNumFiles * ((kFileSize - 1) / kEventSize + 1)),
       events->GetSize());
 
   // Check that the oldest event was dropped from the queue.
   base::Value* event_to_check = nullptr;
   ASSERT_TRUE(events->Get(0, &event_to_check));
+  base::DictionaryValue* dict;
   event_to_check->GetAsDictionary(&dict);
   base::Value* id_value = nullptr;
   ASSERT_TRUE(dict->Get("source.id", &id_value));
   int id;
   ASSERT_TRUE(id_value->GetAsInteger(&id));
   ASSERT_EQ(1, id);
 
   // Check that the last event was written last.
   event_to_check = nullptr;
   ASSERT_TRUE(events->Get(events->GetSize() - 1, &event_to_check));
@@ skipping 19 matching lines @@
 
   logger_->StartObserving(&net_log_, log_path_, nullptr, nullptr,
                           kTotalFileSize, kTotalNumFiles);
 
   AddEntries(kNumEvents, kEventSize);
 
   logger_->StopObserving(nullptr, closure.closure());
 
   closure.WaitForResult();
 
-  std::string input;
-  AddAllFiles(&input);
-  ASSERT_FALSE(input.empty());
-
-  base::JSONReader reader;
-  std::unique_ptr<base::Value> root(reader.ReadToValue(input));
-  ASSERT_TRUE(root) << reader.GetErrorMessage();
-
-  // Check that the correct number of events were written.
-  base::DictionaryValue* dict;
-  ASSERT_TRUE(root->GetAsDictionary(&dict));
+  std::unique_ptr<base::Value> root;
   base::ListValue* events;
-  ASSERT_TRUE(dict->GetList("events", &events));
+  ASSERT_TRUE(ReadNetLogFromDisk(&root, &events));
 
   // Check that the minimum number of events that should fit in event files
   // have been written to all files.
   int events_per_file = (kFileSize - 1) / kEventSize + 1;
   int events_in_last_file = (kNumEvents - 1) % events_per_file + 1;
 
   // Indicates the total number of events that should be written to all files.
   int num_events_in_files =
       (kTotalNumFiles - 1) * events_per_file + events_in_last_file;
 
   // Tracks whether each of the events that should be written to all files
   // actually appears in the |events| array. The bool at each index corresponds
   // to the event with id = index + |kNumEvents| - |num_events_in_files|.
   std::vector<bool> events_written(num_events_in_files, false);
 
   base::Value* event = nullptr;
   base::Value* id_value = nullptr;
   int id;
 
   // Iterate through each event in |events| and if it is supposed to appear in
   // file, mark the corresponding bool in |events_written| as true.
   for (size_t i = 0; i < events->GetSize(); i++) {
     ASSERT_TRUE(events->Get(i, &event));
+    base::DictionaryValue* dict;
     event->GetAsDictionary(&dict);
     ASSERT_TRUE(dict->Get("source.id", &id_value));
     ASSERT_TRUE(id_value->GetAsInteger(&id));
     ASSERT_LT(id, kNumEvents);
     if (id >= kNumEvents - num_events_in_files) {
       events_written[id - (kNumEvents - num_events_in_files)] = true;
     }
   }
 
   // Check that all events that are supposed to be written to all files
@@ skipping 30 matching lines @@
 
   logger_->StartObserving(&net_log_, log_path_, nullptr, nullptr,
                           kTotalFileSize, kTotalNumFiles);
 
   AddEntries(kNumEvents, kEventSize);
 
   logger_->StopObserving(nullptr, closure.closure());
 
   closure.WaitForResult();
 
-  std::string input;
-  AddAllFiles(&input);
-  ASSERT_FALSE(input.empty());
-
-  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::unique_ptr<base::Value> root;
   base::ListValue* events;
-  ASSERT_TRUE(dict->GetList("events", &events));
+  ASSERT_TRUE(ReadNetLogFromDisk(&root, &events));
 
   // Check that the minimum number of events that should fit in event files
   // have been written to a file.
   int events_per_file = (kFileSize - 1) / kEventSize + 1;
   int events_in_last_file = kNumEvents % events_per_file;
   if (!events_in_last_file)
     events_in_last_file = events_per_file;
   int num_events_in_files =
       (kTotalNumFiles - 1) * events_per_file + events_in_last_file;
   std::vector<bool> events_written(num_events_in_files, false);
   base::Value* event = nullptr;
   base::Value* id_value = nullptr;
   int id;
   for (size_t i = 0; i < events->GetSize(); i++) {
     ASSERT_TRUE(events->Get(i, &event));
+    base::DictionaryValue* dict;
     event->GetAsDictionary(&dict);
     ASSERT_TRUE(dict->Get("source.id", &id_value));
     ASSERT_TRUE(id_value->GetAsInteger(&id));
     ASSERT_LT(id, kNumEvents);
     if (id >= kNumEvents - num_events_in_files) {
       events_written[id - (kNumEvents - num_events_in_files)] = true;
     }
   }
   ASSERT_TRUE(std::all_of(std::begin(events_written), std::end(events_written),
                           [](bool j) { return j; }));
@@ skipping 16 matching lines @@
   std::unique_ptr<base::Value> constants(
       new base::StringValue(kConstantString));
 
   logger_->StartObserving(&net_log_, log_path_, constants.get(), nullptr,
                           kLargeFileSize, kTotalNumFiles);
 
   logger_->StopObserving(nullptr, closure.closure());
 
   closure.WaitForResult();
 
-  std::string input;
-  AddAllFiles(&input);
-  ASSERT_FALSE(input.empty());
-
-  base::JSONReader reader;
-  std::unique_ptr<base::Value> root(reader.ReadToValue(input));
-  ASSERT_TRUE(root) << reader.GetErrorMessage();
+  std::unique_ptr<base::Value> root;
+  base::ListValue* events;
+  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_F(BoundedFileNetLogObserverTest, GeneratesValidJSONWithContext) {
   TestClosure closure;
 
   logger_->StartObserving(&net_log_, log_path_, nullptr, nullptr,
                           kLargeFileSize, kTotalNumFiles);
 
   // 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();
 
   logger_->StopObserving(&context, closure.closure());
 
   closure.WaitForResult();
 
-  std::string input;
-  AddAllFiles(&input);
-  ASSERT_FALSE(input.empty());
-
-  base::JSONReader reader;
-  std::unique_ptr<base::Value> root(reader.ReadToValue(input));
-  ASSERT_TRUE(root) << reader.GetErrorMessage();
+  std::unique_ptr<base::Value> root;
+  base::ListValue* events;
+  ASSERT_TRUE(ReadNetLogFromDisk(&root, &events));
 
   // Check that no events were written.
-  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 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);
@@ skipping 15 matching lines @@
       context.CreateRequest(GURL("blah:blah"), IDLE, &delegate));
   request->Start();
 
   logger_->StartObserving(&net_log_, log_path_, nullptr, &context,
                           kLargeFileSize, kTotalNumFiles);
 
   logger_->StopObserving(&context, closure.closure());
 
   closure.WaitForResult();
 
-  std::string input;
-  AddAllFiles(&input);
-  ASSERT_FALSE(input.empty());
-
-  base::JSONReader reader;
-  std::unique_ptr<base::Value> root(reader.ReadToValue(input));
-  ASSERT_TRUE(root) << reader.GetErrorMessage();
+  std::unique_ptr<base::Value> root;
+  base::ListValue* events;
+  ASSERT_TRUE(ReadNetLogFromDisk(&root, &events));
 
   // Check that 1 event was written
-  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* dict;
+  ASSERT_TRUE(root->GetAsDictionary(&dict));
   base::DictionaryValue* tab_info;
   ASSERT_TRUE(dict->GetDictionary("tabInfo", &tab_info));
 }
 
 }  // namespace
 
 }  // namespace net