Generalize the net module's LoadLog facility from a passive container, to an event stream (NetLog).

net/base/load_log_util.cc

-// Copyright (c) 2009 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/base/load_log_util.h"
-
-#include "base/format_macros.h"
-#include "base/string_util.h"
-#include "net/base/net_errors.h"
-
-namespace net {
-namespace {
-
-class FormatHelper {
- public:
-  std::string ToString(const LoadLog* log) {
-    entries_.clear();
-
-    // Pass 1: Match the start/end of indentation blocks. Fills |entries_|
-    // with the results.
-    PopulateEntries(log);
-
-    // Pass 2: Figure out the maximum width of each column. This allows us
-    // to right-justify text within each column.
-    size_t max_time_width, max_indentation, max_type_width, max_dt_width;
-    GetMaxExtent(
-        &max_time_width, &max_indentation, &max_type_width, &max_dt_width);
-
-    // Pass 3: Assemble the string.
-    std::string result;
-
-    const int kSpacesPerIndentation = 2;
-
-    for (size_t i = 0; i < entries_.size(); ++i) {
-      if (log->num_entries_truncated() > 0 && i + 1 == entries_.size()) {
-        StringAppendF(&result, " ... Truncated %" PRIuS " entries ...\n",
-                      log->num_entries_truncated());
-      }
-
-      if (entries_[i].block_index != -1 &&
-          static_cast<size_t>(entries_[i].block_index + 1) == i) {
-        // If there were no entries in between the START/END block then don't
-        // bother printing a line for END (it just adds noise, and we already
-        // show the time delta besides START anyway).
-        continue;
-      }
-
-      int indentation_spaces = entries_[i].indentation * kSpacesPerIndentation;
-      std::string entry_str = GetEntryString(i);
-
-      StringAppendF(&result, "t=%s: %s%s",
-                    PadStringLeft(GetTimeString(i), max_time_width).c_str(),
-                    PadStringLeft("", indentation_spaces).c_str(),
-                    entry_str.c_str());
-
-      if (entries_[i].IsBeginEvent()) {
-        // Summarize how long this block lasted.
-        int padding = ((max_indentation - entries_[i].indentation) *
-            kSpacesPerIndentation) + (max_type_width - entry_str.size());
-        StringAppendF(&result, "%s [dt=%s]",
-                      PadStringLeft("", padding).c_str(),
-                      PadStringLeft(GetBlockDtString(i), max_dt_width).c_str());
-      }
-
-      if (i + 1 != entries_.size())
-        result += "\n";
-    }
-
-    return result;
-  }
-
- private:
-  struct Entry {
-    explicit Entry(const LoadLog::Entry* log_entry)
-        : log_entry(log_entry), indentation(0), block_index(-1) {}
-
-    bool IsBeginEvent() const {
-      return log_entry->type == LoadLog::Entry::TYPE_EVENT &&
-             log_entry->event.phase == LoadLog::PHASE_BEGIN;
-    }
-
-    bool IsEndEvent() const {
-      return log_entry->type == LoadLog::Entry::TYPE_EVENT &&
-             log_entry->event.phase == LoadLog::PHASE_END;
-    }
-
-    const LoadLog::Entry* log_entry;
-    size_t indentation;
-    int block_index;  // The index of the matching start / end of block.
-  };
-
-  void PopulateEntries(const LoadLog* log) {
-    int current_indentation = 0;
-
-    for (size_t i = 0; i < log->entries().size(); ++i) {
-      Entry entry(&log->entries()[i]);
-
-      entry.indentation = current_indentation;
-
-      if (entry.IsBeginEvent()) {
-        // Indent everything contained in this block.
-        current_indentation++;
-      }
-
-      if (entry.IsEndEvent()) {
-        int start_index = FindStartOfBlockIndex(entry);
-        if (start_index != -1) {
-          // Point the start / end of block at each other.
-          entry.block_index = start_index;
-          entries_[start_index].block_index = i;
-
-          // Restore the indentation prior to the block.
-          // (Could be more than 1 level if close of blocks are missing).
-          current_indentation = entries_[start_index].indentation;
-          entry.indentation = current_indentation;
-        }
-      }
-
-      entries_.push_back(entry);
-    }
-  }
-
-  int FindStartOfBlockIndex(const Entry& entry) {
-    DCHECK(entry.IsEndEvent());
-
-    // Find the matching  start of block by scanning backwards.
-    for (int i = entries_.size() - 1; i >= 0; --i) {
-      if (entries_[i].IsBeginEvent() &&
-          entries_[i].log_entry->event.type == entry.log_entry->event.type) {
-        return i;
-      }
-    }
-    return -1;  // Start not found.
-  }
-
-  void GetMaxExtent(size_t* max_time_width,
-                    size_t* max_indentation,
-                    size_t* max_type_width,
-                    size_t* max_dt_width) {
-    *max_time_width = *max_indentation = *max_type_width = *max_dt_width = 0;
-    for (size_t i = 0; i < entries_.size(); ++i) {
-      *max_time_width = std::max(*max_time_width, GetTimeString(i).size());
-      if (entries_[i].log_entry->type == LoadLog::Entry::TYPE_EVENT)
-        *max_type_width = std::max(*max_type_width, GetEntryString(i).size());
-      *max_indentation = std::max(*max_indentation, entries_[i].indentation);
-
-      if (entries_[i].IsBeginEvent())
-        *max_dt_width = std::max(*max_dt_width, GetBlockDtString(i).size());
-    }
-  }
-
-  std::string GetBlockDtString(size_t start_index) {
-    int end_index = entries_[start_index].block_index;
-    if (end_index == -1) {
-      // Block is not closed, implicitly close it at EOF.
-      end_index = entries_.size() - 1;
-    }
-    int64 dt_ms = (entries_[end_index].log_entry->time -
-                   entries_[start_index].log_entry->time).InMilliseconds();
-
-    return Int64ToString(dt_ms);
-  }
-
-  std::string GetTimeString(size_t index) {
-    int64 t_ms = (entries_[index].log_entry->time -
-                  base::TimeTicks()).InMilliseconds();
-    return Int64ToString(t_ms);
-  }
-
-  std::string GetEntryString(size_t index) {
-    const LoadLog::Entry* entry = entries_[index].log_entry;
-
-    std::string entry_str;
-    LoadLog::EventPhase phase = LoadLog::PHASE_NONE;
-    switch (entry->type) {
-      case LoadLog::Entry::TYPE_EVENT:
-        entry_str = LoadLog::EventTypeToString(entry->event.type);
-        phase = entry->event.phase;
-
-        if (phase == LoadLog::PHASE_BEGIN &&
-            index + 1 < entries_.size() &&
-            static_cast<size_t>(entries_[index + 1].block_index) == index) {
-          // If this starts an empty block, we will pretend it is a PHASE_NONE
-          // so we don't print the "+" prefix.
-          phase = LoadLog::PHASE_NONE;
-        }
-        break;
-      case LoadLog::Entry::TYPE_ERROR_CODE:
-        entry_str = StringPrintf("error code: %d (%s)",
-                                 entry->error_code,
-                                 ErrorToString(entry->error_code));
-        break;
-      case LoadLog::Entry::TYPE_STRING:
-        entry_str = StringPrintf("\"%s\"", entry->string.c_str());
-        break;
-      case LoadLog::Entry::TYPE_STRING_LITERAL:
-        entry_str = StringPrintf("\"%s\"", entry->literal);
-        break;
-      default:
-        NOTREACHED();
-    }
-
-    switch (phase) {
-      case LoadLog::PHASE_BEGIN:
-        return std::string("+") + entry_str;
-      case LoadLog::PHASE_END:
-        return std::string("-") + entry_str;
-      case LoadLog::PHASE_NONE:
-        return std::string(" ") + entry_str;
-      default:
-        NOTREACHED();
-        return std::string();
-    }
-  }
-
-  static std::string PadStringLeft(const std::string& str, size_t width) {
-    DCHECK_LE(str.size(), width);
-    std::string padding;
-    padding.resize(width - str.size(), ' ');
-    return padding + str;
-  }
-
-  std::vector<Entry> entries_;
-};
-
-}  // namespace
-
-// static
-std::string LoadLogUtil::PrettyPrintAsEventTree(const LoadLog* log) {
-  FormatHelper helper;
-  return helper.ToString(log);
-}
-
-}  // namespace net