Example of inappropriate cross-thread weak-ptr use.

sql/connection_unittest.cc

 // Copyright (c) 2012 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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/statistics_recorder.h"
+#include "base/single_thread_task_runner.h"
 #include "base/test/histogram_tester.h"
+#include "base/thread_task_runner_handle.h"
+#include "base/threading/thread.h"
 #include "base/trace_event/process_memory_dump.h"
 #include "sql/connection.h"
 #include "sql/connection_memory_dump_provider.h"
 #include "sql/correct_sql_test_base.h"
 #include "sql/meta_table.h"
 #include "sql/statement.h"
 #include "sql/test/error_callback_support.h"
 #include "sql/test/scoped_error_ignorer.h"
 #include "sql/test/test_helpers.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 1455 matching lines @@
 
   // With no key, map everything and create the key.
   // TODO(shess): This really should be "maps everything after validating it",
   // but that is more complicated to structure.
   ASSERT_GT(db().GetAppropriateMmapSize(), kMmapAlot);
   ASSERT_TRUE(MetaTable::GetMmapStatus(&db(), &mmap_status));
   ASSERT_EQ(MetaTable::kMmapSuccess, mmap_status);
 }
 #endif
 
+namespace {
+
+class Demo {
+ public:
+  explicit Demo(scoped_refptr<base::SingleThreadTaskRunner> task_runner)
+      : background_task_runner_(task_runner),
+        weak_ptr_factory_(this) {
+  }
+  ~Demo() {
+  }
+
+  void Ping(
+      scoped_refptr<base::SingleThreadTaskRunner> callback_runner,
+      const base::Closure& callback) {
+    LOG(ERROR) << "Received ping, sleeping";
+    base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
+    LOG(ERROR) << "Sending pong";
+    callback_runner->PostTask(FROM_HERE, callback);
+  }
+
+  void SendPing() {
+    // This use of weak pointer is valid, because it will be
+    // dereferenced when the task is posted back on the current
+    // thread.
+    base::Closure callback(base::Bind(&Demo::Pong,
+                                      weak_ptr_factory_.GetWeakPtr()));
+
+    // This use of weak pointer is not valid, because it will be
+    // dereferenced when the task is posted on the background thread.
+    // It fails the sequence_checker_.CalledOnValidSequencedThread()
+    // DCHECK in WeakReference::Flag::IsValid().
+    background_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&Demo::Ping, weak_ptr_factory_.GetWeakPtr(),
+                   base::ThreadTaskRunnerHandle::Get(), callback));
+  }
+
+  void Pong() {
+    LOG(ERROR) << "Received pong, sleeping";
+    base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
+    LOG(ERROR) << "Sending ping";
+    SendPing();
+  }
+
+  void Start() {
+    LOG(ERROR) << "Sending initial ping";
+    SendPing();
+  }
+
+ private:
+  scoped_refptr<base::SingleThreadTaskRunner> background_task_runner_;
+
+  base::WeakPtrFactory<Demo> weak_ptr_factory_;
+};
+
+}  // namespace
+
+TEST_F(SQLConnectionTest, WeakDemo) {
+  base::MessageLoop message_loop;
+
+  base::Thread background_thread("demo");
+  ASSERT_TRUE(background_thread.Start());
+
+  Demo d(background_thread.task_runner());
+  d.Start();
+}
+
 }  // namespace sql