content/browser/browser_shutdown_profile_dumper.cc

   1 // Copyright 2013 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
   5 #include "content/browser/browser_shutdown_profile_dumper.h"
   6
   7 #include "base/base_switches.h"
   8 #include "base/command_line.h"
   9 #include "base/debug/trace_event.h"
  10 #include "base/debug/trace_event_impl.h"
  11 #include "base/file_util.h"
  12 #include "base/files/file_path.h"
  13 #include "base/logging.h"
  14 #include "base/synchronization/waitable_event.h"
  15 #include "base/threading/thread.h"
  16 #include "base/threading/thread_restrictions.h"
  17 #include "content/public/common/content_switches.h"
  18
  19 namespace content {
  20
  21 BrowserShutdownProfileDumper::BrowserShutdownProfileDumper()
  22     : blocks_(0),
  23       dump_file_(NULL) {
  24 }
  25
  26 BrowserShutdownProfileDumper::~BrowserShutdownProfileDumper() {
  27   WriteTracesToDisc(GetFileName());
  28 }
  29
  30 void BrowserShutdownProfileDumper::WriteTracesToDisc(
  31     const base::FilePath& file_name) {
  32   // Note: I have seen a usage of 0.000xx% when dumping - which fits easily.
  33   // Since the tracer stops when the trace buffer is filled, we'd rather save
  34   // what we have than nothing since we might see from the amount of events
  35   // that caused the problem.
  36   DVLOG(1) << "Flushing shutdown traces to disc. The buffer is %" <<
  37       base::debug::TraceLog::GetInstance()->GetBufferPercentFull() <<
  38       " full.";
  39   DCHECK(!dump_file_);
  40   dump_file_ = base::OpenFile(file_name, "w+");
  41   if (!IsFileValid()) {
  42     LOG(ERROR) << "Failed to open performance trace file: " <<
  43         file_name.value();
  44     return;
  45   }
  46   WriteString("{\"traceEvents\":");
  47   WriteString("[");
  48
  49   // TraceLog::Flush() requires the calling thread to have a message loop.
  50   // As the message loop of the current thread may have quit, start another
  51   // thread for flushing the trace.
  52   base::WaitableEvent flush_complete_event(false, false);
  53   base::Thread flush_thread("browser_shutdown_trace_event_flush");
  54   flush_thread.Start();
  55   flush_thread.message_loop()->PostTask(
  56       FROM_HERE,
  57       base::Bind(&BrowserShutdownProfileDumper::EndTraceAndFlush,
  58                  base::Unretained(this),
  59                  base::Unretained(&flush_complete_event)));
  60
  61   bool original_wait_allowed = base::ThreadRestrictions::SetWaitAllowed(true);
  62   flush_complete_event.Wait();
  63   base::ThreadRestrictions::SetWaitAllowed(original_wait_allowed);
  64 }
  65
  66 void BrowserShutdownProfileDumper::EndTraceAndFlush(
  67     base::WaitableEvent* flush_complete_event) {
  68   base::debug::TraceLog::GetInstance()->SetDisabled();
  69   base::debug::TraceLog::GetInstance()->Flush(
  70       base::Bind(&BrowserShutdownProfileDumper::WriteTraceDataCollected,
  71                  base::Unretained(this),
  72                  base::Unretained(flush_complete_event)));
  73 }
  74
  75 base::FilePath BrowserShutdownProfileDumper::GetFileName() {
  76   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
  77   base::FilePath trace_file =
  78       command_line.GetSwitchValuePath(switches::kTraceShutdownFile);
  79
  80   if (!trace_file.empty())
  81     return trace_file;
  82
  83   // Default to saving the startup trace into the current dir.
  84   return base::FilePath().AppendASCII("chrometrace.log");
  85 }
  86
  87 void BrowserShutdownProfileDumper::WriteTraceDataCollected(
  88     base::WaitableEvent* flush_complete_event,
  89     const scoped_refptr<base::RefCountedString>& events_str,
  90     bool has_more_events) {
  91   if (!IsFileValid()) {
  92     flush_complete_event->Signal();
  93     return;
  94   }
  95   if (blocks_) {
  96     // Blocks are not comma separated. Beginning with the second block we
  97     // start therefore to add one in front of the previous block.
  98     WriteString(",");
  99   }
 100   ++blocks_;
 101   WriteString(events_str->data());
 102
 103   if (!has_more_events) {
 104     WriteString("]");
 105     WriteString("}");
 106     CloseFile();
 107     flush_complete_event->Signal();
 108   }
 109 }
 110
 111 bool BrowserShutdownProfileDumper::IsFileValid() {
 112   return dump_file_ && (ferror(dump_file_) == 0);
 113 }
 114
 115 void BrowserShutdownProfileDumper::WriteString(const std::string& string) {
 116   WriteChars(string.data(), string.size());
 117 }
 118
 119 void BrowserShutdownProfileDumper::WriteChars(const char* chars, size_t size) {
 120   if (!IsFileValid())
 121     return;
 122
 123   size_t written = fwrite(chars, 1, size, dump_file_);
 124   if (written != size) {
 125     LOG(ERROR) << "Error " << ferror(dump_file_) <<
 126         " in fwrite() to trace file";
 127     CloseFile();
 128   }
 129 }
 130
 131 void BrowserShutdownProfileDumper::CloseFile() {
 132   if (!dump_file_)
 133     return;
 134   base::CloseFile(dump_file_);
 135   dump_file_ = NULL;
 136 }
 137
 138 }  // namespace content