Stop manually calling AddRef/Release for AutocompleteController::providers_

chrome/browser/autocomplete/autocomplete_controller.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.
 
 #include "chrome/browser/autocomplete/autocomplete_controller.h"
 
 #include <set>
 #include <string>
 
 #include "base/format_macros.h"
@@ skipping 192 matching lines @@
     search_provider_ = new SearchProvider(this, profile);
     providers_.push_back(search_provider_);
   }
   if (provider_types & AutocompleteProvider::TYPE_SHORTCUTS)
     providers_.push_back(new ShortcutsProvider(this, profile));
   if (provider_types & AutocompleteProvider::TYPE_ZERO_SUGGEST) {
     zero_suggest_provider_ = ZeroSuggestProvider::Create(this, profile);
     if (zero_suggest_provider_)
       providers_.push_back(zero_suggest_provider_);
   }
-
-  for (ACProviders::iterator i(providers_.begin()); i != providers_.end(); ++i)
-    (*i)->AddRef();
 }
 
 AutocompleteController::~AutocompleteController() {
   // The providers may have tasks outstanding that hold refs to them.  We need
   // to ensure they won't call us back if they outlive us.  (Practically,
   // calling Stop() should also cancel those tasks and make it so that we hold
   // the only refs.)  We also don't want to bother notifying anyone of our
   // result changes here, because the notification observer is in the midst of
   // shutdown too, so we don't ask Stop() to clear |result_| (and notify).
   result_.Reset();  // Not really necessary.
   Stop(false);
-
-  for (ACProviders::iterator i(providers_.begin()); i != providers_.end(); ++i)
-    (*i)->Release();
-
-  providers_.clear();  // Not really necessary.
 }
 
 void AutocompleteController::Start(const AutocompleteInput& input) {
   const base::string16 old_input_text(input_.text());
   const bool old_want_asynchronous_matches = input_.want_asynchronous_matches();
   input_ = input;
 
   // See if we can avoid rerunning autocomplete when the query hasn't changed
   // much.  When the user presses or releases the ctrl key, the desired_tld
   // changes, and when the user finishes an IME composition, inline autocomplete
   // may no longer be prevented.  In both these cases the text itself hasn't
   // changed since the last query, and some providers can do much less work (and
   // get matches back more quickly).  Taking advantage of this reduces flicker.
   //
   // NOTE: This comes after constructing |input_| above since that construction
   // can change the text string (e.g. by stripping off a leading '?').
   const bool minimal_changes = (input_.text() == old_input_text) &&
       (input_.want_asynchronous_matches() == old_want_asynchronous_matches);
 
   expire_timer_.Stop();
   stop_timer_.Stop();
 
   // Start the new query.
   in_start_ = true;
   base::TimeTicks start_time = base::TimeTicks::Now();
-  for (ACProviders::iterator i(providers_.begin()); i != providers_.end();
-       ++i) {
+  for (Providers::iterator i(providers_.begin()); i != providers_.end(); ++i) {
     // TODO(mpearson): Remove timing code once bugs 178705 / 237703 / 168933
     // are resolved.
     base::TimeTicks provider_start_time = base::TimeTicks::Now();
 
     // Call Start() on ZeroSuggestProvider with an INVALID AutocompleteInput
     // to clear out zero-suggest |matches_|.
     if (*i == zero_suggest_provider_)
       (*i)->Start(AutocompleteInput(), minimal_changes);
     else
       (*i)->Start(input_, minimal_changes);
@@ skipping 32 matching lines @@
   // need the edit model to update the display.
   UpdateResult(false, true);
 
   if (!done_) {
     StartExpireTimer();
     StartStopTimer();
   }
 }
 
 void AutocompleteController::Stop(bool clear_result) {
-  for (ACProviders::const_iterator i(providers_.begin()); i != providers_.end();
+  for (Providers::const_iterator i(providers_.begin()); i != providers_.end();
        ++i) {
     (*i)->Stop(clear_result);
   }
 
   expire_timer_.Stop();
   stop_timer_.Stop();
   done_ = true;
   if (clear_result && !result_.empty()) {
     result_.Reset();
     // NOTE: We pass in false since we're trying to only clear the popup, not
     // touch the edit... this is all a mess and should be cleaned up :(
     NotifyChanged(false);
   }
 }
 
 void AutocompleteController::StartZeroSuggest(const AutocompleteInput& input) {
   if (zero_suggest_provider_ == NULL)
     return;
 
   DCHECK(!in_start_);  // We should not be already running a query.
 
   // Call Start() on all prefix-based providers with an INVALID
   // AutocompleteInput to clear out cached |matches_|, which ensures that
   // they aren't used with zero suggest.
-  for (ACProviders::iterator i(providers_.begin()); i != providers_.end();
-      ++i) {
+  for (Providers::iterator i(providers_.begin()); i != providers_.end(); ++i) {
     if (*i == zero_suggest_provider_)
       (*i)->Start(input, false);
     else
       (*i)->Start(AutocompleteInput(), false);
   }
 
   if (!zero_suggest_provider_->matches().empty())
     UpdateResult(false, false);
 }
 
@@ skipping 28 matching lines @@
   CheckIfDone();
   // Multiple providers may provide synchronous results, so we only update the
   // results if we're not in Start().
   if (!in_start_ && (updated_matches || done_))
     UpdateResult(false, false);
 }
 
 void AutocompleteController::AddProvidersInfo(
     ProvidersInfo* provider_info) const {
   provider_info->clear();
-  for (ACProviders::const_iterator i(providers_.begin()); i != providers_.end();
+  for (Providers::const_iterator i(providers_.begin()); i != providers_.end();
        ++i) {
     // Add per-provider info, if any.
     (*i)->AddProviderInfo(provider_info);
 
     // This is also a good place to put code to add info that you want to
     // add for every provider.
   }
 }
 
 void AutocompleteController::ResetSession() {
-  for (ACProviders::const_iterator i(providers_.begin()); i != providers_.end();
+  for (Providers::const_iterator i(providers_.begin()); i != providers_.end();
        ++i)
     (*i)->ResetSession();
 }
 
 void AutocompleteController::UpdateMatchDestinationURL(
     base::TimeDelta query_formulation_time,
     AutocompleteMatch* match) const {
   TemplateURL* template_url = match->GetTemplateURL(
       template_url_service_, false);
   if (!template_url || !match->search_terms_args.get() ||
@@ skipping 31 matching lines @@
       last_default_associated_keyword =
           result_.default_match()->associated_keyword->keyword;
   }
 
   if (regenerate_result)
     result_.Reset();
 
   AutocompleteResult last_result;
   last_result.Swap(&result_);
 
-  for (ACProviders::const_iterator i(providers_.begin());
+  for (Providers::const_iterator i(providers_.begin());
        i != providers_.end(); ++i)
     result_.AppendMatches((*i)->matches());
 
   // Sort the matches and trim to a small number of "best" matches.
   result_.SortAndCull(input_, template_url_service_);
 
   // Need to validate before invoking CopyOldMatches as the old matches are not
   // valid against the current input.
 #ifndef NDEBUG
   result_.Validate();
@@ skipping 159 matching lines @@
     delegate_->OnResultChanged(notify_default_match);
   if (done_) {
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_AUTOCOMPLETE_CONTROLLER_RESULT_READY,
         content::Source<AutocompleteController>(this),
         content::NotificationService::NoDetails());
   }
 }
 
 void AutocompleteController::CheckIfDone() {
-  for (ACProviders::const_iterator i(providers_.begin()); i != providers_.end();
+  for (Providers::const_iterator i(providers_.begin()); i != providers_.end();
        ++i) {
     if (!(*i)->done()) {
       done_ = false;
       return;
     }
   }
   done_ = true;
 }
 
 void AutocompleteController::StartExpireTimer() {
   // Amount of time (in ms) between when the user stops typing and
   // when we remove any copied entries. We do this from the time the
   // user stopped typing as some providers (such as SearchProvider)
   // wait for the user to stop typing before they initiate a query.
   const int kExpireTimeMS = 500;
 
   if (result_.HasCopiedMatches())
     expire_timer_.Start(FROM_HERE,
                         base::TimeDelta::FromMilliseconds(kExpireTimeMS),
                         this, &AutocompleteController::ExpireCopiedEntries);
 }
 
 void AutocompleteController::StartStopTimer() {
   stop_timer_.Start(FROM_HERE,
                     stop_timer_duration_,
                     base::Bind(&AutocompleteController::Stop,
                                base::Unretained(this),
                                false));
 }