Remove deprecated methods from MessageLoop on Mac.

base/message_loop/message_loop.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_MESSAGE_LOOP_H_
 #define BASE_MESSAGE_LOOP_MESSAGE_LOOP_H_
 
 #include <memory>
 #include <queue>
 #include <string>
@@ skipping 153 matching lines @@
    public:
     virtual void OnBeginNestedMessageLoop() = 0;
 
    protected:
     virtual ~NestingObserver();
   };
 
   void AddNestingObserver(NestingObserver* observer);
   void RemoveNestingObserver(NestingObserver* observer);
 
+#if !(defined(OS_MACOSX) && !defined(OS_IOS))
   // NOTE: Deprecated; prefer task_runner() and the TaskRunner interfaces.
   // TODO(skyostil): Remove these functions (crbug.com/465354).
   //
   // The "PostTask" family of methods call the task's Run method asynchronously
   // from within a message loop at some point in the future.
   //
   // With the PostTask variant, tasks are invoked in FIFO order, inter-mixed
   // with normal UI or IO event processing.  With the PostDelayedTask variant,
   // tasks are called after at least approximately 'delay_ms' have elapsed.
   //
@@ skipping 50 matching lines @@
   // released (and thus possibly deleted) on the thread that executes
   // MessageLoop::Run().  If this is not the same as the thread that calls
   // ReleaseSoon(FROM_HERE, ), then T MUST inherit from
   // RefCountedThreadSafe<T>!
   template <class T>
   void ReleaseSoon(const tracked_objects::Location& from_here,
                    const T* object) {
     base::subtle::ReleaseHelperInternal<T, void>::ReleaseViaSequencedTaskRunner(
         this, from_here, object);
   }
+#endif  // !(defined(OS_MACOSX) && !defined(OS_IOS))
+
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+ protected:
+#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
 
   // Deprecated: use RunLoop instead.
   // Run the message loop.
   void Run();
 
   // Deprecated: use RunLoop instead.
   // Process all pending tasks, windows messages, etc., but don't wait/sleep.
   // Return as soon as all items that can be run are taken care of.
   void RunUntilIdle();
 
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+ public:
+#endif  // defined(OS_MACOSX) && !defined(OS_IOS)
+
   // Deprecated: use RunLoop instead.
   //
   // Signals the Run method to return when it becomes idle. It will continue to
   // process pending messages and future messages as long as they are enqueued.
   // Warning: if the MessageLoop remains busy, it may never quit. Only use this
   // Quit method when looping procedures (such as web pages) have been shut
   // down.
   //
   // This method may only be called on the same thread that called Run, and Run
   // must still be on the call stack.
@@ skipping 274 matching lines @@
   // A task runner which we haven't bound to a thread yet.
   scoped_refptr<internal::MessageLoopTaskRunner> unbound_task_runner_;
 
   // The task runner associated with this message loop.
   scoped_refptr<SingleThreadTaskRunner> task_runner_;
   std::unique_ptr<ThreadTaskRunnerHandle> thread_task_runner_handle_;
 
   // Id of the thread this message loop is bound to.
   PlatformThreadId thread_id_;
 
+#if !(defined(OS_MACOSX) && !defined(OS_IOS))
   template <class T, class R> friend class base::subtle::DeleteHelperInternal;
   template <class T, class R> friend class base::subtle::ReleaseHelperInternal;
 
   void DeleteSoonInternal(const tracked_objects::Location& from_here,
                           void(*deleter)(const void*),
                           const void* object);
   void ReleaseSoonInternal(const tracked_objects::Location& from_here,
                            void(*releaser)(const void*),
                            const void* object);
+#endif  // !(defined(OS_MACOSX) && !defined(OS_IOS))
 
   DISALLOW_COPY_AND_ASSIGN(MessageLoop);
 };
 
 #if !defined(OS_NACL)
 
 //-----------------------------------------------------------------------------
 // MessageLoopForUI extends MessageLoop with methods that are particular to a
 // MessageLoop instantiated with TYPE_UI.
 //
 // This class is typically used like so:
 //   MessageLoopForUI::current()->...call some method...
 //
 class BASE_EXPORT MessageLoopForUI : public MessageLoop {
  public:
+  using MessageLoop::Run;
+  using MessageLoop::RunUntilIdle;
+
   MessageLoopForUI() : MessageLoop(TYPE_UI) {
   }
 
   explicit MessageLoopForUI(std::unique_ptr<MessagePump> pump);
 
   // Returns the MessageLoopForUI of the current thread.
   static MessageLoopForUI* current() {
     MessageLoop* loop = MessageLoop::current();
     DCHECK(loop);
     DCHECK(loop->IsType(MessageLoop::TYPE_UI));
@@ skipping 40 matching lines @@
 
 //-----------------------------------------------------------------------------
 // MessageLoopForIO extends MessageLoop with methods that are particular to a
 // MessageLoop instantiated with TYPE_IO.
 //
 // This class is typically used like so:
 //   MessageLoopForIO::current()->...call some method...
 //
 class BASE_EXPORT MessageLoopForIO : public MessageLoop {
  public:
+  using MessageLoop::Run;
+  using MessageLoop::RunUntilIdle;
+
   MessageLoopForIO() : MessageLoop(TYPE_IO) {
   }
 
   // Returns the MessageLoopForIO of the current thread.
   static MessageLoopForIO* current() {
     MessageLoop* loop = MessageLoop::current();
     DCHECK(loop);
     DCHECK_EQ(MessageLoop::TYPE_IO, loop->type());
     return static_cast<MessageLoopForIO*>(loop);
   }
@@ skipping 48 matching lines @@
 
 // Do not add any member variables to MessageLoopForIO!  This is important b/c
 // MessageLoopForIO is often allocated via MessageLoop(TYPE_IO).  Any extra
 // data that you need should be stored on the MessageLoop's pump_ instance.
 static_assert(sizeof(MessageLoop) == sizeof(MessageLoopForIO),
               "MessageLoopForIO should not have extra member variables");
 
 }  // namespace base
 
 #endif  // BASE_MESSAGE_LOOP_MESSAGE_LOOP_H_