Implement posting location tracking in WebThread

content/child/webthread_impl.cc

 // Copyright 2014 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.
 
 // An implementation of WebThread in terms of base::MessageLoop and
 // base::Thread
 
 #include "content/child/webthread_impl.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/message_loop/message_loop.h"
 #include "base/pending_task.h"
 #include "base/threading/platform_thread.h"
+#include "third_party/WebKit/public/platform/WebTraceLocation.h"
 
 namespace content {
 
 WebThreadBase::WebThreadBase() {}
 WebThreadBase::~WebThreadBase() {}
 
 class WebThreadBase::TaskObserverAdapter
     : public base::MessageLoop::TaskObserver {
  public:
   TaskObserverAdapter(WebThread::TaskObserver* observer)
@@ skipping 56 matching lines @@
 // When the closure never runs at all, the corresponding WebThread::Task is
 // destructed when base::Closure is deleted (like [B]). In this case, there
 // are no reference counter modification like [A] (because task->run() is not
 // executed), so there are no race conditions.
 // See https://crbug.com/390851 for more details.
 static void RunWebThreadTask(scoped_ptr<blink::WebThread::Task> task) {
     task->run();
 }
 
 void WebThreadImpl::postTask(Task* task) {
-  thread_->message_loop()->PostTask(
-      FROM_HERE,
-      base::Bind(RunWebThreadTask, base::Passed(scoped_ptr<Task>(task))));
+  postDelayedTask(task, 0);
+}
+
+void WebThreadImpl::postTask(const blink::WebTraceLocation& location,
+                             Task* task) {
+  postDelayedTask(location, task, 0);
 }
 
 void WebThreadImpl::postDelayedTask(Task* task, long long delay_ms) {
   thread_->message_loop()->PostDelayedTask(
       FROM_HERE,
       base::Bind(RunWebThreadTask, base::Passed(scoped_ptr<Task>(task))),
       base::TimeDelta::FromMilliseconds(delay_ms));
 }
 
+void WebThreadImpl::postDelayedTask(const blink::WebTraceLocation& web_location,
+                                    Task* task,
+                                    long long delay_ms) {
+  tracked_objects::Location location(web_location.functionName(),
+                                     web_location.fileName(), -1, nullptr);
+  thread_->message_loop()->PostDelayedTask(
+      location,
+      base::Bind(RunWebThreadTask, base::Passed(scoped_ptr<Task>(task))),

[no sievers, 2015/01/23 20:39:47]

nit: make_scoped_ptr

[Sami, 2015/01/26 13:41:17]

Thanks, fixed.

+      base::TimeDelta::FromMilliseconds(delay_ms));
+}
+
 void WebThreadImpl::enterRunLoop() {
   CHECK(isCurrentThread());
   CHECK(!thread_->message_loop()->is_running());  // We don't support nesting.
   thread_->message_loop()->Run();
 }
 
 void WebThreadImpl::exitRunLoop() {
   CHECK(isCurrentThread());
   CHECK(thread_->message_loop()->is_running());
   thread_->message_loop()->Quit();
@@ skipping 10 matching lines @@
 WebThreadImpl::~WebThreadImpl() {
   thread_->Stop();
 }
 
 WebThreadImplForMessageLoop::WebThreadImplForMessageLoop(
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner)
     : main_thread_task_runner_(main_thread_task_runner),
       thread_id_(base::PlatformThread::CurrentId()) {}
 
 void WebThreadImplForMessageLoop::postTask(Task* task) {
-  main_thread_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(RunWebThreadTask, base::Passed(make_scoped_ptr(task))));
+  postDelayedTask(task, 0);
+}
+
+void WebThreadImplForMessageLoop::postTask(
+    const blink::WebTraceLocation& location,
+    Task* task) {
+  postDelayedTask(location, task, 0);
 }
 
 void WebThreadImplForMessageLoop::postDelayedTask(Task* task,
                                                   long long delay_ms) {
   main_thread_task_runner_->PostDelayedTask(
       FROM_HERE,
       base::Bind(RunWebThreadTask, base::Passed(make_scoped_ptr(task))),
       base::TimeDelta::FromMilliseconds(delay_ms));
 }
 
+void WebThreadImplForMessageLoop::postDelayedTask(
+    const blink::WebTraceLocation& web_location,
+    Task* task,
+    long long delay_ms) {
+  tracked_objects::Location location(web_location.functionName(),
+                                     web_location.fileName(), -1, nullptr);
+  main_thread_task_runner_->PostDelayedTask(
+      location,
+      base::Bind(RunWebThreadTask, base::Passed(make_scoped_ptr(task))),
+      base::TimeDelta::FromMilliseconds(delay_ms));
+}
+
 void WebThreadImplForMessageLoop::enterRunLoop() {
   CHECK(isCurrentThread());
   // We don't support nesting.
   CHECK(!base::MessageLoop::current()->is_running());
   base::MessageLoop::current()->Run();
 }
 
 void WebThreadImplForMessageLoop::exitRunLoop() {
   CHECK(isCurrentThread());
   CHECK(base::MessageLoop::current()->is_running());
   base::MessageLoop::current()->Quit();
 }
 
 bool WebThreadImplForMessageLoop::isCurrentThread() const {
   return main_thread_task_runner_->BelongsToCurrentThread();
 }
 
 blink::PlatformThreadId WebThreadImplForMessageLoop::threadId() const {
   return thread_id_;
 }
 
 WebThreadImplForMessageLoop::~WebThreadImplForMessageLoop() {}
 
 }  // namespace content