Fix typo: asynchronus -> asynchronous

chrome/browser/metrics/metrics_service.cc

 // Copyright (c) 2012 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.
 
 //------------------------------------------------------------------------------
 // Description of the life cycle of a instance of MetricsService.
 //
 //  OVERVIEW
 //
 // A MetricsService instance is typically created at application startup.  It
@@ skipping 410 matching lines @@
 
 MetricsService::MetricsService()
     : recording_active_(false),
       reporting_active_(false),
       state_(INITIALIZED),
       low_entropy_source_(0),
       idle_since_last_transmission_(false),
       next_window_id_(0),
       ALLOW_THIS_IN_INITIALIZER_LIST(self_ptr_factory_(this)),
       ALLOW_THIS_IN_INITIALIZER_LIST(state_saver_factory_(this)),
-      waiting_for_asynchronus_reporting_step_(false) {
+      waiting_for_asynchronous_reporting_step_(false) {
   DCHECK(IsSingleThreaded());
   InitializeMetricsState();
 
   base::Closure callback = base::Bind(&MetricsService::StartScheduledUpload,
                                       self_ptr_factory_.GetWeakPtr());
   scheduler_.reset(new MetricsReportingScheduler(callback));
   log_manager_.set_log_serializer(new MetricsLogSerializer());
   log_manager_.set_max_ongoing_log_store_size(kUploadLogAvoidRetransmitSize);
 }
 
@@ skipping 602 matching lines @@
 
   StartFinalLogInfoCollection();
 }
 
 void MetricsService::StartFinalLogInfoCollection() {
   // Begin the multi-step process of collecting memory usage histograms:
   // First spawn a task to collect the memory details; when that task is
   // finished, it will call OnMemoryDetailCollectionDone. That will in turn
   // call HistogramSynchronization to collect histograms from all renderers and
   // then call OnHistogramSynchronizationDone to continue processing.
-  DCHECK(!waiting_for_asynchronus_reporting_step_);
-  waiting_for_asynchronus_reporting_step_ = true;
+  DCHECK(!waiting_for_asynchronous_reporting_step_);
+  waiting_for_asynchronous_reporting_step_ = true;
 
   base::Closure callback =
       base::Bind(&MetricsService::OnMemoryDetailCollectionDone,
                  self_ptr_factory_.GetWeakPtr());
 
   scoped_refptr<MetricsMemoryDetails> details(
       new MetricsMemoryDetails(callback));
   details->StartFetch(MemoryDetails::UPDATE_USER_METRICS);
 
   // Collect WebCore cache information to put into a histogram.
   for (content::RenderProcessHost::iterator i(
           content::RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance())
     i.GetCurrentValue()->Send(new ChromeViewMsg_GetCacheResourceStats());
 }
 
 void MetricsService::OnMemoryDetailCollectionDone() {
   DCHECK(IsSingleThreaded());
   // This function should only be called as the callback from an ansynchronous
   // step.
-  DCHECK(waiting_for_asynchronus_reporting_step_);
+  DCHECK(waiting_for_asynchronous_reporting_step_);
 
   // Create a callback_task for OnHistogramSynchronizationDone.
   base::Closure callback = base::Bind(
       &MetricsService::OnHistogramSynchronizationDone,
       self_ptr_factory_.GetWeakPtr());
 
   base::StatisticsRecorder::CollectHistogramStats("Browser");
 
   // Set up the callback to task to call after we receive histograms from all
   // renderer processes. Wait time specifies how long to wait before absolutely
   // calling us back on the task.
   HistogramSynchronizer::FetchRendererHistogramsAsynchronously(
       MessageLoop::current(), callback,
       base::TimeDelta::FromMilliseconds(kMaxHistogramGatheringWaitDuration));
 }
 
 void MetricsService::OnHistogramSynchronizationDone() {
   DCHECK(IsSingleThreaded());
   // This function should only be called as the callback from an ansynchronous
   // step.
-  DCHECK(waiting_for_asynchronus_reporting_step_);
+  DCHECK(waiting_for_asynchronous_reporting_step_);
 
-  waiting_for_asynchronus_reporting_step_ = false;
+  waiting_for_asynchronous_reporting_step_ = false;
   OnFinalLogInfoCollectionDone();
 }
 
 void MetricsService::OnFinalLogInfoCollectionDone() {
   // If somehow there is a fetch in progress, we return and hope things work
   // out. The scheduler isn't informed since if this happens, the scheduler
   // will get a response from the upload.
   DCHECK(!current_fetch_xml_.get());
   DCHECK(!current_fetch_proto_.get());
   if (current_fetch_xml_.get() || current_fetch_proto_.get())
@@ skipping 106 matching lines @@
     // compressed that, so that we can signal that we're losing logs.
     return;
   }
   // Currently, the staged log for the protobuf version of the data is discarded
   // after we create the URL request, so that there is no chance for
   // re-transmission in case the corresponding XML request fails.  We will
   // handle protobuf failures more carefully once that becomes the main
   // pipeline, i.e. once we switch away from the XML pipeline.
   DCHECK(current_fetch_proto_.get() || !log_manager_.has_staged_log_proto());
 
-  DCHECK(!waiting_for_asynchronus_reporting_step_);
+  DCHECK(!waiting_for_asynchronous_reporting_step_);
 
-  waiting_for_asynchronus_reporting_step_ = true;
+  waiting_for_asynchronous_reporting_step_ = true;
   current_fetch_xml_->Start();
   if (current_fetch_proto_.get())
     current_fetch_proto_->Start();
 
   HandleIdleSinceLastTransmission(true);
 }
 
 void MetricsService::PrepareFetchWithStagedLog() {
   DCHECK(!log_manager_.staged_log_text().empty());
 
@@ skipping 66 matching lines @@
 // arrives.
 //
 // Note that if the XML upload succeeds but the protobuf upload fails, we will
 // not retry the protobuf upload.  If the XML upload fails while the protobuf
 // upload succeeds, we will still avoid re-uploading the protobuf data because
 // we "zap" the data after the first upload attempt.  This means that we might
 // lose protobuf uploads when XML ones succeed; but we will never duplicate any
 // protobuf uploads.  Protobuf failures should be rare enough to where this
 // should be ok while we have the two pipelines running in parallel.
 void MetricsService::OnURLFetchComplete(const net::URLFetcher* source) {
-  DCHECK(waiting_for_asynchronus_reporting_step_);
+  DCHECK(waiting_for_asynchronous_reporting_step_);
 
   // We're not allowed to re-use the existing |URLFetcher|s, so free them here.
   // Note however that |source| is aliased to one of these, so we should be
   // careful not to delete it too early.
   scoped_ptr<net::URLFetcher> s;
   if (source == current_fetch_xml_.get()) {
     s.reset(current_fetch_xml_.release());
 
     // Cache the XML responses, in case we still need to wait for the protobuf
     // response.
@@ skipping 18 matching lines @@
   }
 
   // If we're still waiting for one of the responses, keep waiting...
   if (current_fetch_xml_.get() || current_fetch_proto_.get())
     return;
 
   // We should only be able to reach here once we've received responses to both
   // the XML and the protobuf requests.  We should always have the response code
   // available.
   DCHECK_NE(response_code_, kNoResponseCode);
-  waiting_for_asynchronus_reporting_step_ = false;
+  waiting_for_asynchronous_reporting_step_ = false;
 
   // If the upload was provisionally stored, drop it now that the upload is
   // known to have gone through.
   log_manager_.DiscardLastProvisionalStore();
 
   // Confirm send so that we can move on.
   VLOG(1) << "Metrics response code: " << response_code_
           << " status=" << response_status_;
 
   bool upload_succeeded = response_code_ == 200;
@@ skipping 456 matching lines @@
   if (local_state) {
     const PrefService::Preference* uma_pref =
         local_state->FindPreference(prefs::kMetricsReportingEnabled);
     if (uma_pref) {
       bool success = uma_pref->GetValue()->GetAsBoolean(&result);
       DCHECK(success);
     }
   }
   return result;
 }