Disable MessageLoop features on some BrowserThreads.

base/message_loop/message_loop.cc

 // Copyright 2013 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 "base/message_loop/message_loop.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 106 matching lines @@
     DeletePendingTasks();
     ReloadWorkQueue();
     // If we end up with empty queues, then break out of the loop.
     did_work = DeletePendingTasks();
     if (!did_work)
       break;
   }
   DCHECK(!did_work);
 
   // Let interested parties have one last shot at accessing this.
-  FOR_EACH_OBSERVER(DestructionObserver, destruction_observers_,
-                    WillDestroyCurrentMessageLoop());
+  if (enable_destruction_observers_) {
+    FOR_EACH_OBSERVER(DestructionObserver, destruction_observers_,
+                      WillDestroyCurrentMessageLoop());
+  }
 
   thread_task_runner_handle_.reset();
 
   // Tell the incoming queue that we are dying.
   incoming_task_queue_->WillDestroyCurrentMessageLoop();
   incoming_task_queue_ = NULL;
   unbound_task_runner_ = NULL;
   task_runner_ = NULL;
 
   // OK, now make it so that no one can find us.
@@ skipping 59 matching lines @@
     return std::unique_ptr<MessagePump>(new MessagePumpForUI());
 #endif
 
   DCHECK_EQ(MessageLoop::TYPE_DEFAULT, type);
   return MESSAGE_PUMP_DEFAULT;
 }
 
 void MessageLoop::AddDestructionObserver(
     DestructionObserver* destruction_observer) {
   DCHECK_EQ(this, current());
+  //DCHECK(enable_destruction_observers_);
   destruction_observers_.AddObserver(destruction_observer);
 }
 
 void MessageLoop::RemoveDestructionObserver(
     DestructionObserver* destruction_observer) {
   DCHECK_EQ(this, current());
+  //DCHECK(enable_destruction_observers_);
   destruction_observers_.RemoveObserver(destruction_observer);
 }
 
 void MessageLoop::AddNestingObserver(NestingObserver* observer) {
   DCHECK_EQ(this, current());
+  DCHECK(enable_nesting_);
   nesting_observers_.AddObserver(observer);
 }
 
 void MessageLoop::RemoveNestingObserver(NestingObserver* observer) {
   DCHECK_EQ(this, current());
+  DCHECK(enable_nesting_);
   nesting_observers_.RemoveObserver(observer);
 }
 
 void MessageLoop::QuitWhenIdle() {
   DCHECK_EQ(this, current());
   if (run_loop_) {
     run_loop_->QuitWhenIdle();
   } else {
     NOTREACHED() << "Must be inside Run to call QuitWhenIdle";
   }
@@ skipping 33 matching lines @@
 bool MessageLoop::NestableTasksAllowed() const {
   return nestable_tasks_allowed_;
 }
 
 bool MessageLoop::IsNested() {
   return run_loop_->run_depth_ > 1;
 }
 
 void MessageLoop::AddTaskObserver(TaskObserver* task_observer) {
   DCHECK_EQ(this, current());
+  DCHECK(enable_task_observers_);
   task_observers_.AddObserver(task_observer);
 }
 
 void MessageLoop::RemoveTaskObserver(TaskObserver* task_observer) {
   DCHECK_EQ(this, current());
+  DCHECK(enable_task_observers_);
   task_observers_.RemoveObserver(task_observer);
 }
 
 bool MessageLoop::is_running() const {
   DCHECK_EQ(this, current());
   return run_loop_ != NULL;
 }
 
 bool MessageLoop::HasHighResolutionTasks() {
   return incoming_task_queue_->HasHighResolutionTasks();
@@ skipping 68 matching lines @@
 void MessageLoop::SetThreadTaskRunnerHandle() {
   DCHECK_EQ(this, current());
   // Clear the previous thread task runner first, because only one can exist at
   // a time.
   thread_task_runner_handle_.reset();
   thread_task_runner_handle_.reset(new ThreadTaskRunnerHandle(task_runner_));
 }
 
 void MessageLoop::RunHandler() {
   DCHECK_EQ(this, current());
+  DCHECK(enable_nesting_ || run_loop_->run_depth_ == 1);
   pump_->Run(this);
 }
 
 bool MessageLoop::ProcessNextDelayedNonNestableTask() {
   if (run_loop_->run_depth_ != 1)
     return false;
 
   if (deferred_non_nestable_work_queue_.empty())
     return false;
 
@@ skipping 266 matching lines @@
       persistent,
       mode,
       controller,
       delegate);
 }
 #endif
 
 #endif  // !defined(OS_NACL_SFI)
 
 }  // namespace base