Autofill http auth dialog on os x and linux.

chrome/browser/login_prompt_gtk.cc

 // Copyright (c) 2009 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/login_prompt.h"
 
 #include <gtk/gtk.h>
 
 #include "app/l10n_util.h"
 #include "base/message_loop.h"
 #include "chrome/browser/gtk/constrained_window_gtk.h"
+#include "chrome/browser/login_model.h"
 #include "chrome/browser/password_manager/password_manager.h"
 #include "chrome/browser/renderer_host/resource_dispatcher_host.h"
 #include "chrome/browser/tab_contents/navigation_controller.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/common/gtk_util.h"
 #include "chrome/common/notification_service.h"
 #include "grit/generated_resources.h"
 #include "net/url_request/url_request.h"
 
 using webkit_glue::PasswordForm;
 
 // ----------------------------------------------------------------------------
 // LoginHandlerGtk
 
 // This class simply forwards the authentication from the LoginView (on
 // the UI thread) to the URLRequest (on the I/O thread).
 // This class uses ref counting to ensure that it lives until all InvokeLaters
 // have been called.
 class LoginHandlerGtk : public LoginHandler,
                         public base::RefCountedThreadSafe<LoginHandlerGtk>,
-                        public ConstrainedWindowGtkDelegate {
+                        public ConstrainedWindowGtkDelegate,
+                        public LoginModelObserver {
  public:
   LoginHandlerGtk(URLRequest* request, MessageLoop* ui_loop)
       : handled_auth_(false),
         dialog_(NULL),
         ui_loop_(ui_loop),
         request_(request),
         request_loop_(MessageLoop::current()),
-        password_manager_(NULL) {
+        password_manager_(NULL),
+        login_model_(NULL) {
     DCHECK(request_) << "LoginHandlerGtk constructed with NULL request";
 
     AddRef();  // matched by ReleaseLater.
     if (!ResourceDispatcherHost::RenderViewForRequest(request_,
                                                       &render_process_host_id_,
                                                       &tab_contents_id_)) {
       NOTREACHED();
     }
   }
 
   virtual ~LoginHandlerGtk() {
+    if (login_model_)
+      login_model_->SetObserver(NULL);
     root_.Destroy();
   }
 
+  void SetModel(LoginModel* model) {
+    login_model_ = model;
+    if (login_model_)
+      login_model_->SetObserver(this);
+  }
+
+  // LoginModelObserver implementation.
+  virtual void OnAutofillDataAvailable(const std::wstring& username,
+                                       const std::wstring& password) {
+    // NOTE: Would be nice to use gtk_entry_get_text_length, but it is fairly
+    // new and not always in our GTK version.
+    if (strlen(gtk_entry_get_text(GTK_ENTRY(username_entry_))) == 0) {
+      gtk_entry_set_text(GTK_ENTRY(username_entry_),
+                         WideToUTF8(username).c_str());
+      gtk_entry_set_text(GTK_ENTRY(password_entry_),
+                         WideToUTF8(password).c_str());
+      gtk_editable_select_region(GTK_EDITABLE(username_entry_), 0, -1);
+    }
+  }
+
   // LoginHandler:
   virtual void BuildViewForPasswordManager(PasswordManager* manager,
                                            std::wstring explanation) {
     DCHECK(MessageLoop::current() == ui_loop_);
 
     root_.Own(gtk_vbox_new(NULL, gtk_util::kContentAreaBorder));
     GtkWidget* label = gtk_label_new(WideToUTF8(explanation).c_str());
     gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
     gtk_box_pack_start(GTK_BOX(root_.get()), label, FALSE, FALSE, 0);
 
@@ skipping 19 matching lines @@
     gtk_button_set_label(
         GTK_BUTTON(ok),
         l10n_util::GetStringUTF8(IDS_LOGIN_DIALOG_OK_BUTTON_LABEL).c_str());
     g_signal_connect(ok, "clicked", G_CALLBACK(OnOKClicked), this);
     gtk_box_pack_end(GTK_BOX(hbox), ok, FALSE, FALSE, 0);
 
     GtkWidget* cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
     g_signal_connect(cancel, "clicked", G_CALLBACK(OnCancelClicked), this);
     gtk_box_pack_end(GTK_BOX(hbox), cancel, FALSE, FALSE, 0);
 
+    SetModel(manager);
+
     // Scary thread safety note: This can potentially be called *after* SetAuth
     // or CancelAuth (say, if the request was cancelled before the UI thread got
     // control).  However, that's OK since any UI interaction in those functions
     // will occur via an InvokeLater on the UI thread, which is guaranteed
     // to happen after this is called (since this was InvokeLater'd first).
     dialog_ = GetTabContentsForLogin()->CreateConstrainedDialog(this);
 
     // Now that we have attached ourself to the window, we can make our OK
     // button the default action and mess with the focus.
     GTK_WIDGET_SET_FLAGS(ok, GTK_CAN_DEFAULT);
@@ skipping 194 matching lines @@
   int tab_contents_id_;
 
   // The GtkWidgets that form our visual hierarchy:
   // The root container we pass to our parent.
   OwnedWidgetGtk root_;
 
   // GtkEntry widgets that the user types into.
   GtkWidget* username_entry_;
   GtkWidget* password_entry_;
 
+  // If not null, points to a model we need to notify of our own destruction
+  // so it doesn't try and access this when its too late.
+  LoginModel* login_model_;
+
   DISALLOW_COPY_AND_ASSIGN(LoginHandlerGtk);
 };
 
 // static
 LoginHandler* LoginHandler::Create(URLRequest* request, MessageLoop* ui_loop) {
   return new LoginHandlerGtk(request, ui_loop);
 }