Add granular file tracing.

base/trace_event/scoped_file_trace.cc

Index: base/trace_event/scoped_file_trace.cc
diff --git a/base/trace_event/scoped_file_trace.cc b/base/trace_event/scoped_file_trace.cc
new file mode 100644
index 0000000000000000000000000000000000000000..5073fead9749b40bacba12cca04214eefc82c682
--- /dev/null
+++ b/base/trace_event/scoped_file_trace.cc
@@ -0,0 +1,31 @@
+// Copyright 2015 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 "base/trace_event/scoped_file_trace.h"
+
+#include "base/files/file_path.h"
+#include "base/trace_event/trace_event.h"
+
+namespace base {
+
+// static
+const char ScopedFileTrace::kGroup[] = TRACE_DISABLED_BY_DEFAULT("file");
+
+ScopedFileTrace::ScopedFileTrace(
+    const FilePath& path, const char* event, size_t bytes)
+    : path_(path.AsUTF8Unsafe()), event_(event), bytes_(bytes) {

[Sami, 2015/04/24 10:42:55]

This causes some string copying and memory allocation churn even if tracing is
disabled. Could we avoid that somehow?

[Dan Beam, 2015/04/24 16:37:19]

How is tracing disabled? At compile time or runtime?

There's a couple things we could do. Compile-time:

#if !defined(ENABLE_TRACING)

ScopedFileTrace::ScopedFileTrace(
    const FilePath& path, const char* event, size_t bytes) {}
ScopedFileTrace::~ScopedFileTrace() {}

#else
... functional code ...
#endif

would probably be the easiest if this gets stripped out by the compiler.

Runtime:

ScopedFileTrace::ScopedFileTrace(
    const FilePath& path, const char* event, size_t bytes) {
  if (IsTracingOn()) {
    event_ = event;
    ...
  } else {
    event_ = nullptr;
  }
}
ScopedFileTrace::~ScopedFileTrace() {
  if (event_) {  // instead of IsTracingOn()
    ...
  }
}

Seems like the best way as it only stack allocates 1 size_t, 1 pointer (only set
once), and 1 empty string (maybe 1 pointer? not sure).

Is this sufficient?  We could try to employ some hacks with heap allocation or
use const refs because these are all used in the same scope but these seem like
premature optimizations (and more prone to use-after-free).

I agree we shouldn't copy and/or convert the path from UTF-8 (which will be from
wide on windows, I believe).

[Dan Beam, 2015/04/24 16:44:48]

Or we could just add a bool tracing_enabled_.

[Sami, 2015/04/24 16:45:41]

Tracing is enabled at runtime and included in all builds. You can check if
tracing is enabled via TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED.

However, note that TRACE_EVENT() is already scoped and won't evaluate its
arguments unless tracing is enabled, so it seems like we could just replace
ScopedFileTrace with a corresponding TRACE_EVENT macro invocation like most
other subsystems do. WDYT?

[Dan Beam, 2015/04/24 17:29:50]

We could if we want to duplicate some macros or rewrite base::File to have less
if (...) { return ...; } code paths.  there's about 16 of these currently.

[Sami, 2015/04/24 17:34:47]

I'm not sure I follow? TRACE_EVENT<N> works fine with early returns, e.g:

  {
    TRACE_EVENT0("category", "event");
    if (x > y) {
      return;
    }
    SomeOperation();
  }

The event will either be ended at the return statement or after SomeOperation()
depending on which branch is taken, similar to ScopedFiledTrace.

+  if (bytes_)
+    TRACE_EVENT_BEGIN2(kGroup, event_, "path", path_, "bytes", bytes_);
+  else
+    TRACE_EVENT_BEGIN1(kGroup, event_, "path", path_);
+}
+
+ScopedFileTrace::~ScopedFileTrace() {
+  if (bytes_)
+    TRACE_EVENT_END2(kGroup, event_, "path", path_, "bytes", bytes_);
+  else
+    TRACE_EVENT_END1(kGroup, event_, "path", path_);
+}
+
+}  // namespace base