Avoid holding |incoming_queue_lock_| while waking up the message loop.

base/message_loop/incoming_task_queue.h

 // 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.
 
 #ifndef BASE_MESSAGE_LOOP_INCOMING_TASK_QUEUE_H_
 #define BASE_MESSAGE_LOOP_INCOMING_TASK_QUEUE_H_
 
 #include "base/base_export.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/pending_task.h"
 #include "base/synchronization/lock.h"
+#include "base/synchronization/rw_lock.h"
 #include "base/time/time.h"
 
 namespace base {
 
 class MessageLoop;
 class WaitableEvent;
 
 namespace internal {
 
 // Implements a queue of tasks posted to the message loop running on the current
@@ skipping 32 matching lines @@
   void WillDestroyCurrentMessageLoop();
 
   // This should be called when the message loop becomes ready for
   // scheduling work.
   void StartScheduling();
 
  private:
   friend class RefCountedThreadSafe<IncomingTaskQueue>;
   virtual ~IncomingTaskQueue();
 
-  // Calculates the time at which a PendingTask should run.
-  TimeTicks CalculateDelayedRuntime(TimeDelta delay);
-
   // Adds a task to |incoming_queue_|. The caller retains ownership of
   // |pending_task|, but this function will reset the value of
   // |pending_task->task|. This is needed to ensure that the posting call stack
   // does not retain |pending_task->task| beyond this function call.
   bool PostPendingTask(PendingTask* pending_task);
 
-  // Wakes up the message loop and schedules work.
-  void ScheduleWork();
-
   // Number of tasks that require high resolution timing. This value is kept
   // so that ReloadWorkQueue() completes in constant time.
   int high_res_task_count_;
 
-  // The lock that protects access to the members of this class.
+  // The lock that protects access to the members of this class, except
+  // |message_loop_|.
   base::Lock incoming_queue_lock_;
 
+  // Lock that protects |message_loop_| to prevent it from being deleted while a
+  // task a being posted.

[danakj, 2016/05/19 21:27:43]

is being

[Anand Mistry (off Chromium), 2016/05/20 04:45:38]

Done.

+  base::RWLock message_loop_lock_;
+
   // An incoming queue of tasks that are acquired under a mutex for processing
   // on this instance's thread. These tasks have not yet been been pushed to
   // |message_loop_|.
   TaskQueue incoming_queue_;
 
   // Points to the message loop that owns |this|.
   MessageLoop* message_loop_;
 
   // The next sequence number to use for delayed tasks.
   int next_sequence_num_;
 
   // True if our message loop has already been scheduled and does not need to be
   // scheduled again until an empty reload occurs.
   bool message_loop_scheduled_;
 
   // True if we always need to call ScheduleWork when receiving a new task, even
   // if the incoming queue was not empty.
   const bool always_schedule_work_;
 
   // False until StartScheduling() is called.
   bool is_ready_for_scheduling_;
 
   DISALLOW_COPY_AND_ASSIGN(IncomingTaskQueue);
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_MESSAGE_LOOP_INCOMING_TASK_QUEUE_H_