Fold IPCSupportInitializer::ForceShutdown() with ShutDown().

ipc/mojo/scoped_ipc_support.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 "ipc/mojo/scoped_ipc_support.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 13 matching lines @@
  public:
   IPCSupportInitializer()
       : init_count_(0),
         shutting_down_(false),
         was_shut_down_(false),
         observer_(nullptr) {}
 
   ~IPCSupportInitializer() override { DCHECK(!observer_); }
 
   void Init(scoped_refptr<base::TaskRunner> io_thread_task_runner);
-  void ShutDown();
-
-  // Forces the initializer to shut down even if scopers are still holding it.
-  void ForceShutdown();
+  void ShutDown(bool force);
 
  private:
   // This watches for destruction of the MessageLoop that IPCSupportInitializer
   // uses for IO, and guarantees that the initializer is shut down if it still
   // exists when the loop is being destroyed.
   class MessageLoopObserver : public base::MessageLoop::DestructionObserver {
    public:
     MessageLoopObserver(IPCSupportInitializer* initializer)
         : initializer_(initializer) {}
 
     ~MessageLoopObserver() override {
       base::MessageLoop::current()->RemoveDestructionObserver(this);
     }
 
    private:
     // base::MessageLoop::DestructionObserver:
     void WillDestroyCurrentMessageLoop() override {
-      initializer_->ForceShutdown();
+      initializer_->ShutDown(true);
     }
 
     IPCSupportInitializer* initializer_;
 
     DISALLOW_COPY_AND_ASSIGN(MessageLoopObserver);
   };
 
   void ShutDownOnIOThread();
 
   // mojo::embedder::ProcessDelegate:
@@ skipping 39 matching lines @@
     observer_ = new MessageLoopObserver(this);
     io_thread_task_runner_ = io_thread_task_runner;
     io_thread_task_runner_->PostTask(
         FROM_HERE, base::Bind(&WatchMessageLoopOnIOThread, observer_));
     mojo::embedder::InitIPCSupport(
         mojo::embedder::ProcessType::NONE, io_thread_task_runner_, this,
         io_thread_task_runner_, mojo::embedder::ScopedPlatformHandle());
   }
 }
 
-void IPCSupportInitializer::ShutDown() {
-  {
-    base::AutoLock locker(lock_);
-    if (shutting_down_ || was_shut_down_)
-      return;
-    DCHECK(init_count_ > 0);
-    if (init_count_ > 1) {
-      init_count_--;
-      return;
-    }
-  }
-  ForceShutdown();
-}
-
-void IPCSupportInitializer::ForceShutdown() {
+void IPCSupportInitializer::ShutDown(bool force) {
   base::AutoLock locker(lock_);
   if (shutting_down_ || was_shut_down_)
     return;
+  DCHECK(init_count_ > 0);
+  if (init_count_ > 1 && !force) {
+    init_count_--;
+    return;
+  }
+
   shutting_down_ = true;
   if (base::MessageLoop::current() &&
       base::MessageLoop::current()->task_runner() == io_thread_task_runner_) {
     base::AutoUnlock unlocker_(lock_);
     ShutDownOnIOThread();
   } else {
     io_thread_task_runner_->PostTask(
         FROM_HERE, base::Bind(&IPCSupportInitializer::ShutDownOnIOThread,
                               base::Unretained(this)));
   }
@@ skipping 23 matching lines @@
 base::LazyInstance<IPCSupportInitializer>::Leaky ipc_support_initializer;
 
 }  // namespace
 
 ScopedIPCSupport::ScopedIPCSupport(
     scoped_refptr<base::TaskRunner> io_thread_task_runner) {
   ipc_support_initializer.Get().Init(io_thread_task_runner);
 }
 
 ScopedIPCSupport::~ScopedIPCSupport() {
-  ipc_support_initializer.Get().ShutDown();
+  ipc_support_initializer.Get().ShutDown(false);
 }
 
 }  // namespace IPC