Code cleanup and typos in trace_event [NFC]

base/trace_event/memory_dump_manager.h

 // 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.
 
 #ifndef BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_H_
 #define BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_H_
 
 #include <stdint.h>
 
 #include <map>
@@ skipping 45 matching lines @@
   static std::unique_ptr<MemoryDumpManager> CreateInstanceForTesting();
 
   // Invoked once per process to listen to trace begin / end events.
   // Initialization can happen after (Un)RegisterMemoryDumpProvider() calls
   // and the MemoryDumpManager guarantees to support this.
   // On the other side, the MemoryDumpManager will not be fully operational
   // (i.e. will NACK any RequestGlobalMemoryDump()) until initialized.
   // Arguments:
   //  request_dump_function: Function to invoke a global dump. Global dump
   //      involves embedder-specific behaviors like multiprocess handshaking.
-  //  is_coordinator: True when current process coodinates the periodic dump
+  //  is_coordinator: True when current process coordinates the periodic dump
   //      triggering.
   void Initialize(RequestGlobalDumpFunction request_dump_function,
                   bool is_coordinator);
 
   // (Un)Registers a MemoryDumpProvider instance.
   // Args:
   //  - mdp: the MemoryDumpProvider instance to be registered. MemoryDumpManager
   //      does NOT take memory ownership of |mdp|, which is expected to either
   //      be a singleton or unregister itself.
   //  - name: a friendly name (duplicates allowed). Used for debugging and
@@ skipping 94 matching lines @@
   void set_dumper_registrations_ignored_for_testing(bool ignored) {
     dumper_registrations_ignored_for_testing_ = ignored;
   }
 
  private:
   friend std::default_delete<MemoryDumpManager>;  // For the testing instance.
   friend struct DefaultSingletonTraits<MemoryDumpManager>;
   friend class MemoryDumpManagerTest;
 
   // Holds the state of a process memory dump that needs to be carried over
-  // across task runners in order to fulfil an asynchronous CreateProcessDump()
+  // across task runners in order to fulfill an asynchronous CreateProcessDump()
   // request. At any time exactly one task runner owns a
   // ProcessMemoryDumpAsyncState.
   struct ProcessMemoryDumpAsyncState {
     ProcessMemoryDumpAsyncState(
         MemoryDumpRequestArgs req_args,
         const MemoryDumpProviderInfo::OrderedSet& dump_providers,
         scoped_refptr<HeapProfilerSerializationState>
             heap_profiler_serialization_state,
         ProcessMemoryDumpCallback callback,
         scoped_refptr<SequencedTaskRunner> dump_thread_task_runner);
@@ skipping 81 matching lines @@
 
   // Helper for the public UnregisterDumpProvider* functions.
   void UnregisterDumpProviderInternal(MemoryDumpProvider* mdp,
                                       bool take_mdp_ownership_and_delete_async);
 
   // Fills the passed vector with the subset of dump providers which were
   // registered with is_fast_polling_supported == true.
   void GetDumpProvidersForPolling(
       std::vector<scoped_refptr<MemoryDumpProviderInfo>>*);
 
-  // An ordererd set of registered MemoryDumpProviderInfo(s), sorted by task
+  // An ordered set of registered MemoryDumpProviderInfo(s), sorted by task
   // runner affinity (MDPs belonging to the same task runners are adjacent).
   MemoryDumpProviderInfo::OrderedSet dump_providers_;
 
   // Shared among all the PMDs to keep state scoped to the tracing session.
   scoped_refptr<HeapProfilerSerializationState>
       heap_profiler_serialization_state_;
 
   std::unique_ptr<MemoryTracingObserver> tracing_observer_;
 
   // Function provided by the embedder to handle global dump requests.
@@ skipping 20 matching lines @@
   // Whether new memory dump providers should be told to enable heap profiling.
   bool heap_profiling_enabled_;
 
   DISALLOW_COPY_AND_ASSIGN(MemoryDumpManager);
 };
 
 }  // namespace trace_event
 }  // namespace base
 
 #endif  // BASE_TRACE_EVENT_MEMORY_DUMP_MANAGER_H_