Fixed a few valgrind tests by not assuming the UrlFetcher arrives with the same URL.

chrome/browser/translate/translate_manager.cc

 // Copyright (c) 2011 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/translate/translate_manager.h"
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/json/json_reader.h"
 #include "base/memory/singleton.h"
@@ skipping 331 matching lines @@
       NOTREACHED();
   }
 }
 
 void TranslateManager::OnURLFetchComplete(const URLFetcher* source,
                                           const GURL& url,
                                           const net::URLRequestStatus& status,
                                           int response_code,
                                           const net::ResponseCookies& cookies,
                                           const std::string& data) {
-  scoped_ptr<const URLFetcher> delete_ptr(source);
-  DCHECK(translate_script_request_pending_ || language_list_request_pending_);
-  // We quickly recognize that we are handling a translate script request
-  // if we don't have a language_list_request_pending_. Otherwise we do the
-  // more expensive check of confirming we got the kTranslateScriptURL in the
-  // rare case where we would have both requests pending at the same time.
-  bool translate_script_request = !language_list_request_pending_ ||
-      url == GURL(kTranslateScriptURL);
-  // Here we make sure that if we didn't get the translate_script_request,
-  // we actually got a language_list_request.
-  DCHECK(translate_script_request || url == GURL(kLanguageListFetchURL));
-  if (translate_script_request)
-    translate_script_request_pending_ = false;
-  else
-    language_list_request_pending_ = false;
+  if (translate_script_request_pending_.get() != source &&
+      language_list_request_pending_.get() != source) {
+    // Looks like crash on Mac is possibly caused with callback entering here

[cbentzel, 2011/06/24 19:56:08]

Should you add a CHECK here so we can see failures? This is a definite
programming problem if it happens.

+    // with unknown fetcher when network is refreshed.
+    scoped_ptr<const URLFetcher> delete_ptr(source);
+    return;
+  }
 
-  bool error =
-      (status.status() != net::URLRequestStatus::SUCCESS ||
-       response_code != 200);
-
-  if (translate_script_request) {
+  bool error = (status.status() != net::URLRequestStatus::SUCCESS ||
+                response_code != 200);
+  if (translate_script_request_pending_.get() == source) {
+    scoped_ptr<const URLFetcher> delete_ptr(
+        translate_script_request_pending_.release());
     if (!error) {
       base::StringPiece str = ResourceBundle::GetSharedInstance().
           GetRawDataResource(IDR_TRANSLATE_JS);
       DCHECK(translate_script_.empty());
       str.CopyToString(&translate_script_);
       translate_script_ += "\n" + data;
       // We'll expire the cached script after some time, to make sure long
       // running browsers still get fixes that might get pushed with newer
       // scripts.
       MessageLoop::current()->PostDelayedTask(FROM_HERE,
@@ skipping 22 matching lines @@
         ShowInfoBar(tab, TranslateInfoBarDelegate::CreateErrorDelegate(
             TranslateErrors::NETWORK, tab,
             request.source_lang, request.target_lang));
       } else {
         // Translate the page.
         DoTranslatePage(tab, translate_script_,
                         request.source_lang, request.target_lang);
       }
     }
     pending_requests_.clear();
-  } else {  // if (translate_script_request)
+  } else {  // if (translate_script_request_pending_.get() == source)
+    scoped_ptr<const URLFetcher> delete_ptr(
+        language_list_request_pending_.release());
     if (!error)
       SetSupportedLanguages(data);
     else
       VLOG(1) << "Failed to Fetch languages from: " << kLanguageListFetchURL;
   }
 }
 
 // static
 bool TranslateManager::IsShowingTranslateInfobar(TabContents* tab) {
   return GetTranslateInfoBarDelegate(tab) != NULL;
 }
 
 TranslateManager::TranslateManager()
     : ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
-      translate_script_expiration_delay_(kTranslateScriptExpirationDelayMS),
-      translate_script_request_pending_(false),
-      language_list_request_pending_(false) {
+      translate_script_expiration_delay_(kTranslateScriptExpirationDelayMS) {
   notification_registrar_.Add(this, NotificationType::NAV_ENTRY_COMMITTED,
                               NotificationService::AllSources());
   notification_registrar_.Add(this, NotificationType::TAB_LANGUAGE_DETERMINED,
                               NotificationService::AllSources());
   notification_registrar_.Add(this, NotificationType::PAGE_TRANSLATED,
                               NotificationService::AllSources());
 }
 
 void TranslateManager::InitiateTranslation(TabContents* tab,
                                            const std::string& page_lang) {
@@ skipping 255 matching lines @@
     // the default Accept-Language values for most locales, remove this
     // special-casing.
     if (accept_lang != "en" || is_ui_english)
       accept_langs_set.insert(accept_lang);
   }
   accept_languages_[prefs] = accept_langs_set;
 }
 
 void TranslateManager::FetchLanguageListFromTranslateServer(
     PrefService* prefs) {
-  if (language_list_request_pending_)
+  if (language_list_request_pending_.get() != NULL)
     return;
 
   // We don't want to do this when translate is disabled.
   DCHECK(prefs != NULL);
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kDisableTranslate) ||
       (prefs != NULL && !prefs->GetBoolean(prefs::kEnableTranslate))) {
     return;
   }
 
-  language_list_request_pending_ = true;
-  URLFetcher* fetcher = URLFetcher::Create(1, GURL(kLanguageListFetchURL),
-                                           URLFetcher::GET, this);
-  fetcher->set_request_context(Profile::GetDefaultRequestContext());
-  fetcher->set_max_retries(kMaxRetryLanguageListFetch);
-  fetcher->Start();
+  language_list_request_pending_.reset(URLFetcher::Create(
+      1, GURL(kLanguageListFetchURL), URLFetcher::GET, this));
+  language_list_request_pending_->set_request_context(
+      Profile::GetDefaultRequestContext());
+  language_list_request_pending_->set_max_retries(kMaxRetryLanguageListFetch);
+  language_list_request_pending_->Start();
+}
+
+void TranslateManager::CleanupPendingUlrFetcher() {
+  language_list_request_pending_.reset();
+  translate_script_request_pending_.reset();
 }
 
 void TranslateManager::RequestTranslateScript() {
-  if (translate_script_request_pending_)
+  if (translate_script_request_pending_.get() != NULL)
     return;
 
-  translate_script_request_pending_ = true;
-  URLFetcher* fetcher = URLFetcher::Create(0, GURL(kTranslateScriptURL),
-                                           URLFetcher::GET, this);
-  fetcher->set_request_context(Profile::GetDefaultRequestContext());
-  fetcher->set_extra_request_headers(kTranslateScriptHeader);
-  fetcher->Start();
+  translate_script_request_pending_.reset(URLFetcher::Create(
+      0, GURL(kTranslateScriptURL), URLFetcher::GET, this));
+  translate_script_request_pending_->set_request_context(
+      Profile::GetDefaultRequestContext());
+  translate_script_request_pending_->set_extra_request_headers(
+      kTranslateScriptHeader);
+  translate_script_request_pending_->Start();
 }
 
 void TranslateManager::ShowInfoBar(TabContents* tab,
                                    TranslateInfoBarDelegate* infobar) {
   TranslateInfoBarDelegate* old_infobar = GetTranslateInfoBarDelegate(tab);
   infobar->UpdateBackgroundAnimation(old_infobar);
   TabContentsWrapper* wrapper =
       TabContentsWrapper::GetCurrentWrapperForContents(tab);
   if (old_infobar) {
     // There already is a translate infobar, simply replace it.
@@ skipping 16 matching lines @@
   TabContentsWrapper* wrapper =
       TabContentsWrapper::GetCurrentWrapperForContents(tab);
   for (size_t i = 0; i < wrapper->infobar_count(); ++i) {
     TranslateInfoBarDelegate* delegate =
         wrapper->GetInfoBarDelegateAt(i)->AsTranslateInfoBarDelegate();
     if (delegate)
       return delegate;
   }
   return NULL;
 }