Proof-reading comments in base/message_loop/.

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 <queue>
 #include <string>
 
@@ skipping 290 matching lines @@
   }
 
   // Sets a new TaskRunner for this message loop. The message loop must already
   // have been bound to a thread prior to this call, and the task runner must
   // belong to that thread. Note that changing the task runner will also affect
   // the ThreadTaskRunnerHandle for the target thread. Must be called on the
   // thread to which the message loop is bound.
   void SetTaskRunner(scoped_refptr<SingleThreadTaskRunner> task_runner);
 
   // Enables or disables the recursive task processing. This happens in the case
-  // of recursive message loops. Some unwanted message loop may occurs when
+  // of recursive message loops. Some unwanted message loops may occur when
   // using common controls or printer functions. By default, recursive task
   // processing is disabled.
   //
-  // Please utilize |ScopedNestableTaskAllower| instead of calling these methods
-  // directly.  In general nestable message loops are to be avoided.  They are
+  // Please use |ScopedNestableTaskAllower| instead of calling these methods
+  // directly.  In general, nestable message loops are to be avoided.  They are
   // dangerous and difficult to get right, so please use with extreme caution.
   //
   // The specific case where tasks get queued is:
   // - The thread is running a message loop.
-  // - It receives a task #1 and execute it.
-  // - The task #1 implicitly start a message loop, like a MessageBox in the
+  // - It receives a task #1 and executes it.
+  // - The task #1 implicitly starts a message loop, like a MessageBox in the
   //   unit test. This can also be StartDoc or GetSaveFileName.
   // - The thread receives a task #2 before or while in this second message
   //   loop.
   // - With NestableTasksAllowed set to true, the task #2 will run right away.
   //   Otherwise, it will get executed right after task #1 completes at "thread
   //   message loop level".
   void SetNestableTasksAllowed(bool allowed);
   bool NestableTasksAllowed() const;
 
   // Enables nestable tasks on |loop| while in scope.
@@ skipping 80 matching lines @@
 
   // Creates a MessageLoop without binding to a thread.
   // If |type| is TYPE_CUSTOM non-null |pump_factory| must be also given
   // to create a message pump for this message loop.  Otherwise a default
   // message pump for the |type| is created.
   //
   // It is valid to call this to create a new message loop on one thread,
   // and then pass it to the thread where the message loop actually runs.
   // The message loop's BindToCurrentThread() method must be called on the
   // thread the message loop runs on, before calling Run().
-  // Before BindToCurrentThread() is called only Post*Task() functions can
+  // Before BindToCurrentThread() is called, only Post*Task() functions can
   // be called on the message loop.
   static scoped_ptr<MessageLoop> CreateUnbound(
       Type type,
       MessagePumpFactoryCallback pump_factory);
 
   // Common private constructor. Other constructors delegate the initialization
   // to this constructor.
   MessageLoop(Type type, MessagePumpFactoryCallback pump_factory);
 
   // Configure various members and bind this message loop to the current thread.
@@ skipping 70 matching lines @@
   // once we're out of nested message loops.
   TaskQueue deferred_non_nestable_work_queue_;
 
   ObserverList<DestructionObserver> destruction_observers_;
 
   // A recursion block that prevents accidentally running additional tasks when
   // insider a (accidentally induced?) nested message pump.
   bool nestable_tasks_allowed_;
 
 #if defined(OS_WIN)
-  // Should be set to true before calling Windows APIs like TrackPopupMenu, etc
+  // Should be set to true before calling Windows APIs like TrackPopupMenu, etc.
   // which enter a modal message loop.
   bool os_modal_loop_;
 #endif
 
   // pump_factory_.Run() is called to create a message pump for this loop
   // if type_ is TYPE_CUSTOM and pump_ is null.
   MessagePumpFactoryCallback pump_factory_;
 
   std::string thread_name_;
   // A profiling histogram showing the counts of various messages and events.
@@ skipping 162 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.
 COMPILE_ASSERT(sizeof(MessageLoop) == sizeof(MessageLoopForIO),
                MessageLoopForIO_should_not_have_extra_member_variables);
 
 }  // namespace base
 
 #endif  // BASE_MESSAGE_LOOP_MESSAGE_LOOP_H_