RefCounted types should not have public destructors, chrome/browser/ui

chrome/browser/ui/login/login_prompt.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/ui/login/login_prompt.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 87 matching lines @@
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&LoginHandler::AddObservers, this));
 
   if (!ResourceRequestInfo::ForRequest(request_)->GetAssociatedRenderView(
           &render_process_host_id_,  &tab_contents_id_)) {
     NOTREACHED();
   }
 }
 
-LoginHandler::~LoginHandler() {
-  SetModel(NULL);
+void LoginHandler::OnRequestCancelled() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)) <<
+      "Why is OnRequestCancelled called from the UI thread?";
+
+  // Reference is no longer valid.
+  request_ = NULL;
+
+  // Give up on auth if the request was cancelled.
+  CancelAuth();
 }
 
 void LoginHandler::SetPasswordForm(const webkit::forms::PasswordForm& form) {
   password_form_ = form;
 }
 
 void LoginHandler::SetPasswordManager(PasswordManager* password_manager) {
   password_manager_ = password_manager;
 }
 
@@ skipping 57 matching lines @@
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&LoginHandler::CloseContentsDeferred, this));
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&LoginHandler::CancelAuthDeferred, this));
 }
 
-void LoginHandler::OnRequestCancelled() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)) <<
-      "Why is OnRequestCancelled called from the UI thread?";
-
-  // Reference is no longer valid.
-  request_ = NULL;
-
-  // Give up on auth if the request was cancelled.
-  CancelAuth();
-}
-
-void LoginHandler::AddObservers() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  // This is probably OK; we need to listen to everything and we break out of
-  // the Observe() if we aren't handling the same auth_info().
-  registrar_.reset(new content::NotificationRegistrar);
-  registrar_->Add(this, chrome::NOTIFICATION_AUTH_SUPPLIED,
-                  content::NotificationService::AllBrowserContextsAndSources());
-  registrar_->Add(this, chrome::NOTIFICATION_AUTH_CANCELLED,
-                  content::NotificationService::AllBrowserContextsAndSources());
-}
-
-void LoginHandler::RemoveObservers() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  registrar_.reset();
-}
 
 void LoginHandler::Observe(int type,
                            const content::NotificationSource& source,
                            const content::NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(type == chrome::NOTIFICATION_AUTH_SUPPLIED ||
          type == chrome::NOTIFICATION_AUTH_CANCELLED);
 
   WebContents* requesting_contents = GetWebContentsForLogin();
   if (!requesting_contents)
@@ skipping 23 matching lines @@
   if (type == chrome::NOTIFICATION_AUTH_SUPPLIED) {
     AuthSuppliedLoginNotificationDetails* supplied_details =
         content::Details<AuthSuppliedLoginNotificationDetails>(details).ptr();
     SetAuth(supplied_details->username(), supplied_details->password());
   } else {
     DCHECK(type == chrome::NOTIFICATION_AUTH_CANCELLED);
     CancelAuth();
   }
 }
 
+// Returns whether authentication had been handled (SetAuth or CancelAuth).
+bool LoginHandler::WasAuthHandled() const {
+  base::AutoLock lock(handled_auth_lock_);
+  bool was_handled = handled_auth_;
+  return was_handled;
+}
+
+LoginHandler::~LoginHandler() {
+  SetModel(NULL);
+}
+
 void LoginHandler::SetModel(LoginModel* model) {
   if (login_model_)
     login_model_->SetObserver(NULL);
   login_model_ = model;
   if (login_model_)
     login_model_->SetObserver(this);
 }
 
 void LoginHandler::SetDialog(ConstrainedWindow* dialog) {
   dialog_ = dialog;
@@ skipping 12 matching lines @@
   if (requesting_contents)
     controller = &requesting_contents->GetController();
 
   LoginNotificationDetails details(this);
 
   service->Notify(chrome::NOTIFICATION_AUTH_NEEDED,
                   content::Source<NavigationController>(controller),
                   content::Details<LoginNotificationDetails>(&details));
 }
 
-void LoginHandler::NotifyAuthCancelled() {
+void LoginHandler::ReleaseSoon() {
+  if (!TestAndSetAuthHandled()) {
+    BrowserThread::PostTask(
+        BrowserThread::IO, FROM_HERE,
+        base::Bind(&LoginHandler::CancelAuthDeferred, this));
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&LoginHandler::NotifyAuthCancelled, this));
+  }
+
+  BrowserThread::PostTask(
+    BrowserThread::UI, FROM_HERE,
+    base::Bind(&LoginHandler::RemoveObservers, this));
+
+  // Delete this object once all InvokeLaters have been called.
+  BrowserThread::ReleaseSoon(BrowserThread::IO, FROM_HERE, this);
+}
+
+void LoginHandler::AddObservers() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(WasAuthHandled());
 
-  content::NotificationService* service =
-      content::NotificationService::current();
-  NavigationController* controller = NULL;
+  // This is probably OK; we need to listen to everything and we break out of
+  // the Observe() if we aren't handling the same auth_info().
+  registrar_.reset(new content::NotificationRegistrar);
+  registrar_->Add(this, chrome::NOTIFICATION_AUTH_SUPPLIED,
+                  content::NotificationService::AllBrowserContextsAndSources());
+  registrar_->Add(this, chrome::NOTIFICATION_AUTH_CANCELLED,
+                  content::NotificationService::AllBrowserContextsAndSources());
+}
 
-  WebContents* requesting_contents = GetWebContentsForLogin();
-  if (requesting_contents)
-    controller = &requesting_contents->GetController();
+void LoginHandler::RemoveObservers() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  LoginNotificationDetails details(this);
-
-  service->Notify(chrome::NOTIFICATION_AUTH_CANCELLED,
-                  content::Source<NavigationController>(controller),
-                  content::Details<LoginNotificationDetails>(&details));
+  registrar_.reset();
 }
 
 void LoginHandler::NotifyAuthSupplied(const string16& username,
                                       const string16& password) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(WasAuthHandled());
 
   WebContents* requesting_contents = GetWebContentsForLogin();
   if (!requesting_contents)
     return;
 
   content::NotificationService* service =
       content::NotificationService::current();
   NavigationController* controller =
       &requesting_contents->GetController();
   AuthSuppliedLoginNotificationDetails details(this, username, password);
 
   service->Notify(
       chrome::NOTIFICATION_AUTH_SUPPLIED,
       content::Source<NavigationController>(controller),
       content::Details<AuthSuppliedLoginNotificationDetails>(&details));
 }
 
-void LoginHandler::ReleaseSoon() {
-  if (!TestAndSetAuthHandled()) {
-    BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE,
-        base::Bind(&LoginHandler::CancelAuthDeferred, this));
-    BrowserThread::PostTask(
-        BrowserThread::UI, FROM_HERE,
-        base::Bind(&LoginHandler::NotifyAuthCancelled, this));
-  }
+void LoginHandler::NotifyAuthCancelled() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(WasAuthHandled());
 
-  BrowserThread::PostTask(
-    BrowserThread::UI, FROM_HERE,
-    base::Bind(&LoginHandler::RemoveObservers, this));
+  content::NotificationService* service =
+      content::NotificationService::current();
+  NavigationController* controller = NULL;
 
-  // Delete this object once all InvokeLaters have been called.
-  BrowserThread::ReleaseSoon(BrowserThread::IO, FROM_HERE, this);
-}
+  WebContents* requesting_contents = GetWebContentsForLogin();
+  if (requesting_contents)
+    controller = &requesting_contents->GetController();
 
-// Returns whether authentication had been handled (SetAuth or CancelAuth).
-bool LoginHandler::WasAuthHandled() const {
-  base::AutoLock lock(handled_auth_lock_);
-  bool was_handled = handled_auth_;
-  return was_handled;
+  LoginNotificationDetails details(this);
+
+  service->Notify(chrome::NOTIFICATION_AUTH_CANCELLED,
+                  content::Source<NavigationController>(controller),
+                  content::Details<LoginNotificationDetails>(&details));
 }
 
 // Marks authentication as handled and returns the previous handled state.
 bool LoginHandler::TestAndSetAuthHandled() {
   base::AutoLock lock(handled_auth_lock_);
   bool was_handled = handled_auth_;
   handled_auth_ = true;
   return was_handled;
 }
 
@@ skipping 114 matching lines @@
 
 LoginHandler* CreateLoginPrompt(net::AuthChallengeInfo* auth_info,
                                 net::URLRequest* request) {
   LoginHandler* handler = LoginHandler::Create(auth_info, request);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&LoginDialogCallback, request->url(),
                  make_scoped_refptr(auth_info), make_scoped_refptr(handler)));
   return handler;
 }