Remove thread TaskRunner hack from ChannelAssociatedGroupController

ipc/ipc_mojo_bootstrap.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.
 
 #include "ipc/ipc_mojo_bootstrap.h"
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <utility>
 #include <vector>
 
-#include "base/atomicops.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
-#include "base/stl_util.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "build/build_config.h"
-#include "ipc/ipc_message_utils.h"
-#include "ipc/ipc_platform_file.h"
 #include "mojo/public/cpp/bindings/associated_group.h"
 #include "mojo/public/cpp/bindings/associated_group_controller.h"
-#include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/connector.h"
 #include "mojo/public/cpp/bindings/interface_endpoint_client.h"
 #include "mojo/public/cpp/bindings/interface_endpoint_controller.h"
 #include "mojo/public/cpp/bindings/interface_id.h"
 #include "mojo/public/cpp/bindings/message.h"
 #include "mojo/public/cpp/bindings/message_header_validator.h"
 #include "mojo/public/cpp/bindings/pipe_control_message_handler.h"
 #include "mojo/public/cpp/bindings/pipe_control_message_handler_delegate.h"
 #include "mojo/public/cpp/bindings/pipe_control_message_proxy.h"
 
@@ skipping 18 matching lines @@
         control_message_proxy_thunk_(this),
         control_message_proxy_(&control_message_proxy_thunk_) {
     thread_checker_.DetachFromThread();
     control_message_handler_.SetDescription(
         "IPC::mojom::Bootstrap [master] PipeControlMessageHandler");
   }
 
   void Bind(mojo::ScopedMessagePipeHandle handle) {
     DCHECK(thread_checker_.CalledOnValidThread());
     DCHECK(task_runner_->BelongsToCurrentThread());
-    thread_task_runner_ = base::ThreadTaskRunnerHandle::Get();
-    base::subtle::Release_Store(&is_thread_task_runner_set_, 1);
 
     connector_.reset(new mojo::Connector(
         std::move(handle), mojo::Connector::SINGLE_THREADED_SEND,
         task_runner_));
     connector_->set_incoming_receiver(&header_validator_);
     connector_->set_connection_error_handler(
         base::Bind(&ChannelAssociatedGroupController::OnPipeError,
                    base::Unretained(this)));
 
     std::vector<std::unique_ptr<mojo::Message>> outgoing_messages;
@@ skipping 124 matching lines @@
     DCHECK(mojo::IsValidInterfaceId(id));
 
     base::AutoLock locker(lock_);
     DCHECK(ContainsKey(endpoints_, id));
 
     Endpoint* endpoint = endpoints_[id].get();
     endpoint->DetachClient();
   }
 
   void RaiseError() override {
-    if (IsRunningOnIPCThread()) {
+    if (task_runner_->BelongsToCurrentThread()) {
       connector_->RaiseError();
     } else {
       task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&ChannelAssociatedGroupController::RaiseError, this));
     }
   }
 
  private:
   class Endpoint;
@@ skipping 71 matching lines @@
 
       // TODO(rockot): Implement sync waiting.
       NOTREACHED();
     }
 
     bool SyncWatch(const bool* should_stop) override {
       DCHECK(task_runner_->BelongsToCurrentThread());
 
       // It's not legal to make sync calls from the master endpoint's thread,
       // and in fact they must only happen from the proxy task runner.
-      DCHECK(!controller_->IsRunningOnIPCThread());
+      DCHECK(!controller_->task_runner_->BelongsToCurrentThread());
       DCHECK(controller_->proxy_task_runner_->BelongsToCurrentThread());
 
       // TODO(rockot): Implement sync waiting.
       NOTREACHED();
       return false;
     }
 
    private:
     friend class base::RefCountedThreadSafe<Endpoint>;
 
@@ skipping 35 matching lines @@
       Endpoint* endpoint = iter->second.get();
       ++iter;
 
       DCHECK(endpoint->closed());
       MarkPeerClosedAndMaybeRemove(endpoint);
     }
 
     DCHECK(endpoints_.empty());
   }
 
-  bool IsRunningOnIPCThread() {
-    // |task_runner_| is always non-null but may incorrectly report that
-    // BelongsToCurrentThread() == false during shutdown. By the time shutdown
-    // occurs, |thread_task_runner_| will be non-null and is guaranteed to run
-    // tasks on the same thread as |task_runner_|.
-    base::subtle::Atomic32 has_thread_task_runner =
-        base::subtle::Acquire_Load(&is_thread_task_runner_set_);
-    if (has_thread_task_runner)
-      return thread_task_runner_->BelongsToCurrentThread();
-    return task_runner_->BelongsToCurrentThread();
-  }
-
   bool SendMessage(mojo::Message* message) {
-    if (IsRunningOnIPCThread()) {
+    if (task_runner_->BelongsToCurrentThread()) {
       DCHECK(thread_checker_.CalledOnValidThread());
       if (!connector_) {
         // Pipe may not be bound yet, so we queue the message.
         std::unique_ptr<mojo::Message> queued_message(new mojo::Message);
         message->MoveTo(queued_message.get());
         outgoing_messages_.emplace_back(std::move(queued_message));
         return true;
       }
       return connector_->Accept(message);
     } else {
@@ skipping 220 matching lines @@
     MarkClosedAndMaybeRemove(endpoint);
     control_message_proxy_.NotifyPeerEndpointClosed(id);
     return true;
   }
 
   // Checked in places which must be run on the master endpoint's thread.
   base::ThreadChecker thread_checker_;
 
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
-  // A TaskRunner that runs tasks on the same thread as |task_runner_| but which
-  // is used exclusively to do thread safety checking. This is an unfortunate
-  // consequence of bad interaction between some TaskRunner implementations and
-  // MessageLoop destruction which may cause the user-provided |task_runner_| to
-  // incorrectly report that BelongsToCurrentThread() == false during shutdown.
-  scoped_refptr<base::SingleThreadTaskRunner> thread_task_runner_;
-  base::subtle::Atomic32 is_thread_task_runner_set_ = 0;
-
   scoped_refptr<base::SingleThreadTaskRunner> proxy_task_runner_;
   const bool set_interface_id_namespace_bit_;
   std::unique_ptr<mojo::Connector> connector_;
   mojo::MessageHeaderValidator header_validator_;
   mojo::PipeControlMessageHandler control_message_handler_;
   ControlMessageProxyThunk control_message_proxy_thunk_;
   mojo::PipeControlMessageProxy control_message_proxy_;
 
   // Outgoing messages that were sent before this controller was bound to a
   // real message pipe.
@@ skipping 61 matching lines @@
     Channel::Mode mode,
     Delegate* delegate,
     const scoped_refptr<base::SingleThreadTaskRunner>& ipc_task_runner) {
   return base::MakeUnique<MojoBootstrapImpl>(
       std::move(handle), delegate,
       new ChannelAssociatedGroupController(mode == Channel::MODE_SERVER,
                                            ipc_task_runner));
 }
 
 }  // namespace IPC