Add CHECKs to investigate crashes in BytesConsumerForDataConsumerHandle

content/child/shared_memory_data_consumer_handle.cc

 // 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 "content/child/shared_memory_data_consumer_handle.h"
 
 #include <algorithm>
 #include <deque>
 #include <utility>
 
@@ skipping 90 matching lines @@
   Result result() const {
     lock_.AssertAcquired();
     return result_;
   }
   void set_result(Result r) {
     lock_.AssertAcquired();
     result_ = r;
   }
   void AcquireReaderLock(Client* client) {
     lock_.AssertAcquired();
-    DCHECK(!notification_task_runner_);
-    DCHECK(!client_);
+    // TODO(yhirano): Turn these CHECKs to DCHECKs once the crash is fixed.
+    CHECK(!notification_task_runner_);
+    CHECK(!client_);
     notification_task_runner_ = base::ThreadTaskRunnerHandle::Get();
     client_ = client;
     if (client && !(IsEmpty() && result() == Ok)) {
       // We cannot notify synchronously because the user doesn't have the reader
       // yet.
       notification_task_runner_->PostTask(
           FROM_HERE, base::Bind(&Context::NotifyInternal, this, false));
     }
   }
   void ReleaseReaderLock() {
     lock_.AssertAcquired();
-    DCHECK(notification_task_runner_);
+    // TODO(yhirano): Turn these CHECKs to DCHECKs once the crash is fixed.
+    CHECK(notification_task_runner_);
+    CHECK(notification_task_runner_->BelongsToCurrentThread());
     notification_task_runner_ = nullptr;
     client_ = nullptr;
   }
   void PostNotify() {
     lock_.AssertAcquired();
     auto runner = notification_task_runner_;
     if (!runner)
       return;
     // We don't re-post the task when the runner changes while waiting for
     // this task because in this case a new reader is obtained and
@@ skipping 81 matching lines @@
       // We don't re-post the task when the runner changes while waiting for
       // this task because in this case a new reader is obtained and
       // notification is already done at the reader creation time if necessary.
       runner->PostTask(FROM_HERE,
                        base::Bind(&Context::NotifyInternal, this, false));
     }
   }
   void Clear() {
     lock_.AssertAcquired();
     ClearQueue();
-    client_ = nullptr;
+    // Turn this CHECK to DCHECK.
+    CHECK(!client_);
     ResetOnReaderDetached();
   }
   // Must be called with |lock_| not aquired.
   void ResetOnReaderDetachedWithLock() {
     base::AutoLock lock(lock_);
     ResetOnReaderDetached();
   }
 
   friend class base::RefCountedThreadSafe<Context>;
   ~Context() = default;
@@ skipping 214 matching lines @@
 std::unique_ptr<blink::WebDataConsumerHandle::Reader>
 SharedMemoryDataConsumerHandle::obtainReader(Client* client) {
   return base::WrapUnique(new ReaderImpl(context_, client));
 }
 
 const char* SharedMemoryDataConsumerHandle::debugName() const {
   return "SharedMemoryDataConsumerHandle";
 }
 
 }  // namespace content