Revert 123140 - Use SequencedWorkerPool for disk operations in TraceSubscriberStdio.

content/browser/trace_subscriber_stdio.cc

-// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Copyright (c) 2011 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 "content/browser/trace_subscriber_stdio.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
-#include "base/threading/sequenced_worker_pool.h"
-#include "content/public/browser/browser_thread.h"
 
-namespace content {
+TraceSubscriberStdio::TraceSubscriberStdio() : file_(0) {
+}
 
-// All method calls on this class are done on a SequencedWorkerPool thread.
-class TraceSubscriberStdioImpl
-    : public base::RefCountedThreadSafe<TraceSubscriberStdioImpl> {
- public:
-  explicit TraceSubscriberStdioImpl(const FilePath& path)
-      : path_(path),
-        file_(0) {}
-
-  ~TraceSubscriberStdioImpl() {
-    CloseFile();
-  }
-
-  void OnStart() {
-    DCHECK(!file_);
-    file_ = file_util::OpenFile(path_, "w+");
-    if (IsValid()) {
-      LOG(INFO) << "Logging performance trace to file: " << path_.value();
-      trace_buffer_.SetOutputCallback(
-          base::Bind(&TraceSubscriberStdioImpl::Write, this));
-      trace_buffer_.Start();
-    } else {
-      LOG(ERROR) << "Failed to open performance trace file: " << path_.value();
-    }
-  }
-
-  void OnData(const scoped_refptr<base::RefCountedString>& data_ptr) {
-    trace_buffer_.AddFragment(data_ptr->data());
-  }
-
-  void OnEnd() {
-    trace_buffer_.Finish();
-    CloseFile();
-  }
-
- private:
-  bool IsValid() {
-    return file_ && (0 == ferror(file_));
-  }
-
-  void CloseFile() {
-    if (file_) {
-      fclose(file_);
-      file_ = 0;
-    }
-  }
-
-  void Write(const std::string& output_str) {
-    if (IsValid()) {
-      size_t written = fwrite(output_str.data(), 1, output_str.size(), file_);
-      if (written != output_str.size()) {
-        LOG(ERROR) << "Error " << ferror(file_) << " in fwrite() to trace file";
-        CloseFile();
-      }
-    }
-  }
-
-  FilePath path_;
-  FILE* file_;
-  base::debug::TraceResultBuffer trace_buffer_;
-};
-
-TraceSubscriberStdio::TraceSubscriberStdio(const FilePath& path)
-    : impl_(new TraceSubscriberStdioImpl(path)) {
-  BrowserThread::PostBlockingPoolSequencedTask(
-      __FILE__, FROM_HERE,
-      base::Bind(&TraceSubscriberStdioImpl::OnStart, impl_.get()));
+TraceSubscriberStdio::TraceSubscriberStdio(const FilePath& path) : file_(0) {
+  OpenFile(path);
 }
 
 TraceSubscriberStdio::~TraceSubscriberStdio() {
+  CloseFile();
+}
+
+bool TraceSubscriberStdio::OpenFile(const FilePath& path) {
+  LOG(INFO) << "Logging performance trace to file: " << path.value();
+  CloseFile();
+  file_ = file_util::OpenFile(path, "w+");
+  if (IsValid()) {
+    trace_buffer_.SetOutputCallback(base::Bind(&TraceSubscriberStdio::Write,
+                                               base::Unretained(this)));
+    trace_buffer_.Start();
+    return true;
+  } else {
+    LOG(ERROR) << "Failed to open performance trace file: " << path.value();
+    return false;
+  }
+}
+
+void TraceSubscriberStdio::CloseFile() {
+  if (file_) {
+    fclose(file_);
+    file_ = 0;
+  }
+}
+
+bool TraceSubscriberStdio::IsValid() {
+  return file_ && (0 == ferror(file_));
 }
 
 void TraceSubscriberStdio::OnEndTracingComplete() {
-  BrowserThread::PostBlockingPoolSequencedTask(
-      __FILE__, FROM_HERE,
-      base::Bind(&TraceSubscriberStdioImpl::OnEnd, impl_.get()));
+  trace_buffer_.Finish();
+  CloseFile();
 }
 
 void TraceSubscriberStdio::OnTraceDataCollected(
-    const scoped_refptr<base::RefCountedString>& data_ptr) {
-  BrowserThread::PostBlockingPoolSequencedTask(
-      __FILE__, FROM_HERE,
-      base::Bind(&TraceSubscriberStdioImpl::OnData, impl_.get(), data_ptr));
+    const std::string& trace_fragment) {
+  trace_buffer_.AddFragment(trace_fragment);
 }
 
-}  // namespace content
-
+void TraceSubscriberStdio::Write(const std::string& output_str) {
+  if (IsValid()) {
+    size_t written = fwrite(output_str.data(), 1, output_str.size(), file_);
+    if (written != output_str.size()) {
+      LOG(ERROR) << "Error " << ferror(file_) << " when writing to trace file";
+      CloseFile();
+    }
+  }
+}