Imported Upstream version 14.04.10

1 files changed, 1603 insertions, 0 deletions

diff --git a/src/user-list.vala b/src/user-list.vala
new file mode 100644
index 0000000..5f2bceb
--- /dev/null
+++ b/src/user-list.vala
@@ -0,0 +1,1603 @@
+/* -*- Mode: Vala; indent-tabs-mode: nil; tab-width: 4 -*-
+ *
+ * Copyright (C) 2011,2012 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authors: Robert Ancell <robert.ancell@canonical.com>
+ *          Michael Terry <michael.terry@canonical.com>
+ */
+
+int remote_server_field_sort_function (RemoteServerField? item1, RemoteServerField? item2)
+{
+    string[] sorted_fields = { "domain", "username", "email", "password" };
+    foreach (var field in sorted_fields)
+    {
+        if (item1.type == field)
+            return -1;
+        if (item2.type == field)
+            return 1;
+    }
+
+    return (item1.type < item2.type) ? -1 : 0;
+}
+
+public class UserList : GreeterList
+{
+    private bool _offer_guest = false;
+    public bool offer_guest
+    {
+        get { return _offer_guest; }
+        set
+        {
+            _offer_guest = value;
+            if (value)
+                add_user ("*guest", _("Guest Session"));
+            else
+                remove_entry ("*guest");
+        }
+    }
+
+    private Gdk.Pixbuf message_pixbuf;
+
+    private uint change_background_timeout = 0;
+
+    private uint remote_login_service_watch;
+    private RemoteLoginService remote_login_service;
+    private List<RemoteServer?> remote_directory_server_list = new List<RemoteServer?> ();
+    private List<RemoteServer?> remote_login_server_list = new List<RemoteServer?> ();
+    private HashTable<string, Gtk.Widget> current_remote_fields;
+    private string currently_browsing_server_url;
+    private string currently_browsing_server_email;
+    private EmailAutocompleter remote_server_email_field_autocompleter;
+
+    /* User to authenticate against */
+    private string ?authenticate_user = null;
+
+    private bool show_hidden_users_ = false;
+    public bool show_hidden_users
+    {
+        set
+        {
+            show_hidden_users_ = value;
+
+            if (UnityGreeter.singleton.test_mode)
+            {
+                if (value)
+                    add_user ("hidden", "Hidden User", null, false, false, null);
+                else
+                    remove_entry ("hidden");
+                return;
+            }
+
+            var hidden_users = UGSettings.get_strv (UGSettings.KEY_HIDDEN_USERS);
+            if (!value)
+            {
+                foreach (var username in hidden_users)
+                    remove_entry (username);
+                return;
+            }
+
+            var users = LightDM.UserList.get_instance ();
+            foreach (var user in users.users)
+            {
+                foreach (var username in hidden_users)
+                {
+                    if (user.name == username)
+                    {
+                        debug ("Showing hidden user %s", username);
+                        user_added_cb (user);
+                    }
+                }
+            }
+        }
+
+        get
+        {
+            return show_hidden_users_;
+        }
+    }
+
+    private string _default_session = "ubuntu";
+    public string default_session
+    {
+        get
+        {
+            return _default_session;
+        }
+        set
+        {
+            _default_session = value;
+            if (selected_entry != null)
+                selected_entry.set_options_image (get_badge ());
+        }
+    }
+
+    private string? _session = null;
+    public string? session
+    {
+        get
+        {
+            return _session;
+        }
+        set
+        {
+            _session = value;
+            if (selected_entry != null)
+                selected_entry.set_options_image (get_badge ());
+        }
+    }
+
+    public UserList (Background bg, MenuBar mb)
+    {
+        Object (background: bg, menubar: mb);
+    }
+
+    construct
+    {
+        menubar.notify["high-contrast"].connect (() => { change_background (); });
+        entry_displayed_start.connect (() => { change_background (); });
+        entry_displayed_done.connect (() => { change_background (); });
+
+        try
+        {
+            message_pixbuf = new Gdk.Pixbuf.from_file (Path.build_filename (Config.PKGDATADIR, "message.png", null));
+        }
+        catch (Error e)
+        {
+            debug ("Error loading message image: %s", e.message);
+        }
+
+        fill_list ();
+
+        entry_selected.connect (entry_selected_cb);
+
+        connect_to_lightdm ();
+
+        if (!UnityGreeter.singleton.test_mode &&
+            UnityGreeter.singleton.show_remote_login_hint ())
+            remote_login_service_watch = Bus.watch_name (BusType.SESSION,
+                                            "com.canonical.RemoteLogin",
+                                            BusNameWatcherFlags.AUTO_START,
+                                            on_remote_login_service_appeared,
+                                            on_remote_login_service_vanished);
+
+    }
+
+    private void remove_remote_servers ()
+    {
+        remote_directory_server_list = new List<RemoteServer?> ();
+        remote_login_server_list = new List<RemoteServer?> ();
+        remove_entries_with_prefix ("*remote");
+    }
+
+    private void remove_remote_login_servers ()
+    {
+        remote_login_server_list = new List<RemoteServer?> ();
+        remove_entries_with_prefix ("*remote_login");
+
+        /* If we have no entries at all, we should show manual */
+        if (!always_show_manual)
+            add_manual_entry ();
+    }
+
+    private async void query_directory_servers ()
+    {
+        try
+        {
+            RemoteServer[] server_list;
+            yield remote_login_service.get_servers (out server_list);
+            set_remote_directory_servers (server_list);
+        }
+        catch (IOError e)
+        {
+            debug ("Calling GetServers on com.canonical.RemoteLogin dbus service failed. Error: %s", e.message);
+            remove_remote_servers ();
+        }
+    }
+
+    private string user_list_name_for_remote_directory_server (RemoteServer remote_server)
+    {
+        return "*remote_directory*" + remote_server.url;
+    }
+
+    private string username_from_remote_server_fields(RemoteServer remote_server)
+    {
+        var username = "";
+        foreach (var f in remote_server.fields)
+        {
+            if (f.type == "username" && f.default_value != null)
+            {
+                username = f.default_value.get_string ();
+                break;
+            }
+        }
+        return username;
+     }
+
+    private string user_list_name_for_remote_login_server (RemoteServer remote_server)
+    {
+        var username = username_from_remote_server_fields (remote_server);
+        return "*remote_login*" + remote_server.url + "*" + username;
+    }
+
+    private string url_from_remote_loding_server_list_name (string remote_server_list_name)
+    {
+        return remote_server_list_name.split ("*")[2];
+    }
+    
+    private string username_from_remote_loding_server_list_name (string remote_server_list_name)
+    {
+        return remote_server_list_name.split ("*")[3];
+    }
+
+    private void set_remote_directory_servers (RemoteServer[] server_list)
+    {
+        /* Add new servers */
+        foreach (var remote_server in server_list)
+        {
+            var list_name = user_list_name_for_remote_directory_server (remote_server);
+            if (find_entry (list_name) == null)
+            {
+                var e = new PromptBox (list_name);
+                e.label = remote_server.name;
+                e.respond.connect (remote_directory_respond_cb);
+                e.show_options.connect (show_remote_account_dialog);
+                add_entry (e);
+
+                remote_directory_server_list.append (remote_server);
+            }
+        }
+
+        /* Remove gone servers */
+        unowned List<RemoteServer?> it = remote_directory_server_list;
+        while (it != null)
+        {
+            var remote_server = it.data;
+            var found = false;
+            for (int i = 0; !found && i < server_list.length; i++)
+            {
+                found = remote_server.url == server_list[i].url;
+            }
+            if (!found)
+            {
+                if (remote_server.url == currently_browsing_server_url)
+                {
+                    /* The server we where "browsing" disappeared, so kill its children */
+                    remove_remote_login_servers ();
+                    currently_browsing_server_url = "";
+                    currently_browsing_server_email = "";
+                }
+                remove_entry (user_list_name_for_remote_directory_server (remote_server));
+                unowned List<RemoteServer?> newIt = it.next;
+                remote_directory_server_list.delete_link (it);
+                it = newIt;
+            }
+            else
+            {
+                it = it.next;
+            }
+        }
+
+        /* Remove manual option unless specified */
+        if (remote_directory_server_list.length() > 0 && !always_show_manual) {
+            debug ("removing manual login since we have a remote login entry");
+            remove_entry ("*other");
+        }
+    }
+
+    private PromptBox create_prompt_for_login_server (RemoteServer remote_server)
+    {
+        var e = new PromptBox (user_list_name_for_remote_login_server (remote_server));
+        e.label = remote_server.name;
+        e.respond.connect (remote_login_respond_cb);
+        add_entry (e);
+        remote_login_server_list.append (remote_server);
+
+        return e;
+    }
+
+    private void remote_login_servers_updated (string url, string email_address, string data_type, RemoteServer[] server_list)
+    {
+        if (currently_browsing_server_url == url && currently_browsing_server_email == email_address)
+        {
+            /* Add new servers */
+            foreach (var remote_server in server_list)
+            {
+                var list_name = user_list_name_for_remote_login_server (remote_server);
+                if (find_entry (list_name) == null)
+                    create_prompt_for_login_server (remote_server);
+            }
+
+            /* Remove gone servers */
+            unowned List<RemoteServer?> it = remote_login_server_list;
+            while (it != null)
+            {
+                RemoteServer remote_server = it.data;
+                var found = false;
+                for (var i = 0; !found && i < server_list.length; i++)
+                    found = remote_server.url == server_list[i].url;
+                if (!found)
+                {
+                    remove_entry (user_list_name_for_remote_login_server (remote_server));
+                    unowned List<RemoteServer?> newIt = it.next;
+                    remote_login_server_list.delete_link (it);
+                    it = newIt;
+                }
+                else
+                {
+                    it = it.next;
+                }
+            }
+        }
+    }
+
+    private void remote_login_changed (string url, string email_address)
+    {
+        if (currently_browsing_server_url == url && currently_browsing_server_email == email_address)
+        {
+            /* Something happened and we are being asked for re-authentication by the remote-login-service */
+            remove_remote_login_servers ();
+            currently_browsing_server_url = "";
+            currently_browsing_server_email = "";
+
+            var directory_list_name = "*remote_directory*" + url;
+            set_active_entry (directory_list_name);
+        }
+    }
+
+    private void on_remote_login_service_appeared (DBusConnection conn, string name)
+    {
+        Bus.get_proxy.begin<RemoteLoginService> (BusType.SESSION,
+            "com.canonical.RemoteLogin",
+            "/com/canonical/RemoteLogin",
+            0,
+            null,
+            (obj, res) => {
+                try
+                {
+                    remote_login_service = Bus.get_proxy.end<RemoteLoginService> (res);
+                    remote_login_service.servers_updated.connect (set_remote_directory_servers);
+                    remote_login_service.login_servers_updated.connect (remote_login_servers_updated);
+                    remote_login_service.login_changed.connect (remote_login_changed);
+                    query_directory_servers.begin ();
+                }
+                catch (IOError e)
+                {
+                    debug ("Getting the com.canonical.RemoteLogin dbus service failed. Error: %s", e.message);
+                    remove_remote_servers ();
+                    remote_login_service = null;
+                }
+            }
+        );
+    }
+
+    private void on_remote_login_service_vanished (DBusConnection conn, string name)
+    {
+        remove_remote_servers ();
+        remote_login_service = null;
+
+        /* provide a fallback manual login option */
+        if (UnityGreeter.singleton.hide_users_hint ()) {
+            add_manual_entry();
+            set_active_entry ("*other");
+        }
+    }
+
+    private async void remote_directory_respond_cb ()
+    {
+        remove_remote_login_servers ();
+        currently_browsing_server_url = "";
+        currently_browsing_server_email = "";
+
+        var password_field = current_remote_fields.get ("password") as DashEntry;
+        var email_field = current_remote_fields.get ("email") as Gtk.Entry;
+        if (password_field == null)
+        {
+            debug ("Something wrong happened in remote_directory_respond_cb. There was no password field");
+            return;
+        }
+        if (email_field == null)
+        {
+            debug ("Something wrong happened in remote_directory_respond_cb. There was no email field");
+            return;
+        }
+
+        RemoteServer[] server_list = {};
+        var email = email_field.text;
+        var email_valid = false;
+        try
+        {
+            /* Check email address is valid
+             * Using the html5 definition of a valid e-mail address
+             * http://www.w3.org/TR/html5/states-of-the-type-attribute.html#valid-e-mail-address */
+            var re = new Regex ("[a-zA-Z0-9.!#$%&'\\*\\+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\\.[a-zA-Z0-9-]+)*");
+            MatchInfo info;
+            email_valid = re.match_all (email, 0, out info);
+            email_valid = email_valid && info.get_match_count () > 0 && info.fetch (0) == email;
+        }
+        catch (RegexError e)
+        {
+            debug ("Calling email regex match failed. Error: %s", e.message);
+        }
+
+        selected_entry.reset_messages ();
+        if (!email_valid)
+        {
+            will_clear = true;
+            show_message (_("Please enter a complete e-mail address"), true);
+            create_remote_fields_for_current_item.begin (remote_directory_server_list);
+        }
+        else
+        {
+            var login_success = false;
+            try
+            {
+                var url = url_from_remote_loding_server_list_name (selected_entry.id);
+                if (UnityGreeter.singleton.test_mode)
+                {
+                    if (password_field.text == "password")
+                    {
+                        test_fill_remote_login_servers (out server_list);
+                        login_success = true;
+                    }
+                    else if (password_field.text == "delay1")
+                    {
+                        test_fill_remote_login_servers (out server_list);
+                        login_success = true;
+                        Timeout.add (5000, () => { test_call_set_remote_directory_servers (); return false; });
+                    }
+                    else if (password_field.text == "delay2")
+                    {
+                        test_fill_remote_login_servers (out server_list);
+                        login_success = true;
+                        Timeout.add (5000, () => { test_call_remote_login_servers_updated (); return false; });
+                    }
+                    else if (password_field.text == "delay3")
+                    {
+                        test_fill_remote_login_servers (out server_list);
+                        login_success = true;
+                        Timeout.add (5000, () => { remote_login_changed (currently_browsing_server_url, currently_browsing_server_email); return false; });
+                    }
+                    else if (password_field.text == "duplicate")
+                    {
+                        test_fill_remote_login_servers_duplicate_entries (out server_list);
+                        login_success = true;                        
+                    }
+                }
+                else
+                {
+                    string data_type;
+                    bool allowcache = true;
+                    // If we had an error and are retrying the same user and server, do not use the cache on R-L-S
+                    if (selected_entry.has_errors && currently_browsing_server_email == email && currently_browsing_server_url == url)
+                        allowcache = false;
+                    yield remote_login_service.get_servers_for_login (url, email, password_field.text, allowcache, out login_success, out data_type, out server_list);
+                }
+                currently_browsing_server_url = url;
+                currently_browsing_server_email = email;
+            }
+            catch (IOError e)
+            {
+                debug ("Calling get_servers in com.canonical.RemoteLogin dbus service failed. Error: %s", e.message);
+            }
+
+            if (login_success)
+            {
+                password_field.did_respond = false;
+                if (server_list.length == 0)
+                    show_remote_account_dialog ();
+                else
+                {
+                    var last_used_server_list_name = "";
+                    foreach (var remote_server in server_list)
+                    {
+                        var e = create_prompt_for_login_server (remote_server);
+                        if (remote_server.last_used_server)
+                            last_used_server_list_name = e.id;
+                    }
+                    if (last_used_server_list_name != "")
+                        set_active_entry (last_used_server_list_name);
+                    else
+                        set_active_first_entry_with_prefix ("*remote_login");
+                }
+            }
+            else
+            {
+                will_clear = true;
+                show_message (_("Incorrect e-mail address or password"), true);
+                create_remote_fields_for_current_item.begin (remote_directory_server_list);
+            }
+        }
+    }
+
+    private void remote_login_respond_cb ()
+    {
+        sensitive = false;
+        will_clear = true;
+        greeter_authenticating_user = selected_entry.id;
+        if (UnityGreeter.singleton.test_mode)
+        {
+            Gtk.Entry field = current_remote_fields.get ("password") as Gtk.Entry;
+            test_is_authenticated = field.text == "password";
+            if (field.text == "delay")
+                Timeout.add (5000, () => { authentication_complete_cb (); return false; });
+            else
+                authentication_complete_cb ();
+        }
+        else
+        {
+            UnityGreeter.singleton.authenticate_remote (get_lightdm_session (), null);
+            remote_login_service.set_last_used_server.begin (currently_browsing_server_url, url_from_remote_loding_server_list_name (selected_entry.id));
+        }
+    }
+
+    private void show_remote_account_dialog ()
+    {
+        var dialog = new Gtk.MessageDialog (null, 0, Gtk.MessageType.OTHER, Gtk.ButtonsType.NONE, "");
+        dialog.set_position (Gtk.WindowPosition.CENTER_ALWAYS);
+        dialog.secondary_text = _("If you have an account on an RDP or Citrix server, Remote Login lets you run applications from that server.");
+        // For 12.10 we still don't support Citrix
+        dialog.secondary_text = _("If you have an account on an RDP server, Remote Login lets you run applications from that server.");
+        if (offer_guest)
+        {
+            dialog.add_button (_("Cancel"), 0);
+            var b = dialog.add_button (_("Set Up…"), 1);
+            b.grab_focus ();
+            dialog.text = _("You need an Ubuntu Remote Login account to use this service. Would you like to set up an account now?");
+        }
+        else
+        {
+            dialog.add_button (_("OK"), 0);
+            dialog.text = _("You need an Ubuntu Remote Login account to use this service. Visit uccs.canonical.com to set up an account.");
+        }
+
+        dialog.show_all ();
+        dialog.response.connect ((id) =>
+        {
+            if (id == 1)
+            {
+                var config_session = "uccsconfigure";
+                if (is_supported_remote_session (config_session))
+                {
+                    greeter_authenticating_user = selected_entry.id;
+                    UnityGreeter.singleton.authenticate_remote (config_session, null);
+                }
+            }
+            dialog.destroy ();
+        });
+        dialog.run ();
+    }
+
+    private bool change_background_timeout_cb ()
+    {
+        string? new_background_file = null;
+        if (menubar.high_contrast || !UGSettings.get_boolean (UGSettings.KEY_DRAW_USER_BACKGROUNDS))
+            new_background_file = null;
+        else if (selected_entry is UserPromptBox)
+            new_background_file = (selected_entry as UserPromptBox).background;
+
+        background.current_background = new_background_file;
+
+        change_background_timeout = 0;
+        return false;
+    }
+
+    private void change_background ()
+    {
+        if (background.current_background != null)
+        {
+            if (change_background_timeout == 0)
+                change_background_timeout = Idle.add (change_background_timeout_cb);
+        }
+        else
+            change_background_timeout_cb ();
+    }
+
+    protected static int user_list_compare_entry (PromptBox a, PromptBox b)
+    {
+        if (a.id.has_prefix ("*remote_directory") && !b.id.has_prefix ("*remote_directory"))
+            return 1;
+        if (a.id.has_prefix ("*remote_login") && !b.id.has_prefix ("*remote_login"))
+            return 1;
+
+        /* Fall back to default behaviour of the GreeterList sorter */
+        return GreeterList.compare_entry (a, b);
+    }
+
+    protected override void insert_entry (PromptBox entry)
+    {
+        entries.insert_sorted (entry, user_list_compare_entry);
+    }
+
+    protected override void setup_prompt_box (bool fade = true)
+    {
+        base.setup_prompt_box (fade);
+        var userbox = selected_entry as UserPromptBox;
+        if (userbox != null)
+            selected_entry.set_is_active (userbox.is_active);
+    }
+
+    private void entry_selected_cb (string? username)
+    {
+        UnityGreeter.singleton.set_state ("last-user", username);
+        if (selected_entry is UserPromptBox)
+            session = (selected_entry as UserPromptBox).session;
+        else
+            session = null;
+        selected_entry.clear ();
+
+        /* Reset this variable so it can be freed */
+        remote_server_email_field_autocompleter = null;
+
+        start_authentication ();
+    }
+
+    protected override void start_authentication ()
+    {
+        sensitive = true;
+        greeter_authenticating_user = "";
+        if (selected_entry.id.has_prefix ("*remote_directory"))
+        {
+            prompted = true;
+            create_remote_fields_for_current_item.begin (remote_directory_server_list);
+        }
+        else if (selected_entry.id.has_prefix ("*remote_login"))
+        {
+            prompted = true;
+            create_remote_fields_for_current_item.begin (remote_login_server_list);
+        }
+        else
+            base.start_authentication ();
+    }
+
+    private async void create_remote_fields_for_current_item (List<RemoteServer?> server_list)
+    {
+        current_remote_fields = new HashTable<string, Gtk.Widget> (str_hash, str_equal);
+        var url = url_from_remote_loding_server_list_name (selected_entry.id);
+        var username = username_from_remote_loding_server_list_name (selected_entry.id);
+        
+        foreach (var remote_server in server_list)
+        {
+            var remote_username = username_from_remote_server_fields (remote_server);
+            if (remote_server.url == url && (username == null || username == remote_username))
+            {
+                if (selected_entry.id.has_prefix ("*remote_login"))
+                {
+                    if (!is_supported_remote_session (remote_server.type))
+                    {
+                        show_message (_("Server type not supported."), true);
+                    }
+                }
+
+                var fields = new List<RemoteServerField?> ();
+                foreach (var field in remote_server.fields)
+                    fields.append (field);
+                fields.sort (remote_server_field_sort_function);
+                foreach (var field in fields)
+                {
+                    Gtk.Widget? widget = null;
+                    var default_value = "";
+                    if (field.default_value != null && field.default_value.is_of_type (VariantType.STRING))
+                        default_value = field.default_value.get_string ();
+                    if (field.type == "username")
+                    {
+                        var entry = add_prompt (_("Username:"));
+                        entry.text = default_value;
+                        widget = entry;
+                    }
+                    else if (field.type == "password")
+                    {
+                        var entry = add_prompt (_("Password:"), true);
+                        entry.text = default_value;
+                        widget = entry;
+                    }
+                    else if (field.type == "domain")
+                    {
+                        string[] domainsArray = {};
+                        if (field.properties != null && field.properties.contains ("domains") && field.properties.get ("domains").is_of_type (VariantType.ARRAY))
+                            domainsArray = field.properties.get ("domains").dup_strv ();
+                        var domains = new GenericArray<string> ();
+                        for (var i = 0; i < domainsArray.length; i++)
+                            domains.add (domainsArray[i]);
+
+                        var read_only = field.properties != null &&
+                                        field.properties.contains ("read-only") &&
+                                        field.properties.get ("read-only").is_of_type (VariantType.BOOLEAN) &&
+                                        field.properties.get ("read-only").get_boolean ();
+                        if (domains.length == 0 || (domains.length == 1 && (domains[0] == default_value || default_value.length == 0)))
+                        {
+                            var prompt = add_prompt (_("Domain:"));
+                            prompt.text = domains.length == 1 ? domains[0] : default_value;
+                            prompt.sensitive = !read_only;
+                            widget = prompt;
+                        }
+                        else
+                        {
+                            if (default_value.length > 0)
+                            {
+                                /* Make sure the domain list contains the default value */
+                                var found = false;
+                                for (var i = 0; !found && i < domains.length; i++)
+                                    found = default_value == domains[i];
+
+                                if (!found)
+                                    domains.add (default_value);
+                            }
+
+                            /* Sort domains alphabetically */
+                            domains.sort (strcmp);
+                            var combo = add_combo (domains, read_only);
+
+                            if (default_value.length > 0)
+                            {
+                                if (read_only)
+                                {
+                                    for (var i = 0; i < domains.length; i++)
+                                    {
+                                        if (default_value == domains[i])
+                                        {
+                                            combo.active = i;
+                                            break;
+                                        }
+                                    }
+                                }
+                                else
+                                {
+                                    var entry = combo.get_child () as Gtk.Entry;
+                                    entry.text = default_value;
+                                }
+                            }
+
+                            widget = combo;
+                        }
+                    }
+                    else if (field.type == "email")
+                    {
+                        string[] email_domains;
+                        try
+                        {
+                            if (UnityGreeter.singleton.test_mode)
+                                email_domains = { "canonical.com", "ubuntu.org", "candy.com", "urban.net" };
+                            else
+                                yield remote_login_service.get_cached_domains_for_server (url, out email_domains);
+                        }
+                        catch (IOError e)
+                        {
+                            email_domains.resize (0);
+                            debug ("Calling get_cached_domains_for_server in com.canonical.RemoteLogin dbus service failed. Error: %s", e.message);
+                        }
+
+                        var entry = add_prompt (_("Email address:"));
+                        entry.text = default_value;
+                        widget = entry;
+                        if (email_domains.length > 0)
+                            remote_server_email_field_autocompleter = new EmailAutocompleter (entry, email_domains);
+                    }
+                    else
+                    {
+                        debug ("Found field of type %s, don't know what to do with it", field.type);
+                        continue;
+                    }
+                    current_remote_fields.insert (field.type, widget);
+                }
+                break;
+            }
+        }
+    }
+
+    public override void focus_prompt ()
+    {
+        if (selected_entry.id.has_prefix ("*remote_login"))
+        {
+            var url = url_from_remote_loding_server_list_name(selected_entry.id);
+            foreach (var remote_server in remote_login_server_list)
+            {
+                if (remote_server.url == url)
+                {
+                    if (!is_supported_remote_session (remote_server.type))
+                    {
+                        selected_entry.sensitive = false;
+                        return;
+                    }
+                }
+            }
+        }
+
+        base.focus_prompt ();
+    }
+
+    public override void show_authenticated (bool successful = true)
+    {
+        if (successful)
+        {
+            /* 'Log In' here is the button for logging in. */
+            selected_entry.add_button (_("Log In"),
+                                       _("Login as %s").printf (selected_entry.label));
+        }
+        else
+        {
+            selected_entry.add_button (_("Retry"),
+                                       _("Retry as %s").printf (selected_entry.label));
+        }
+
+        if (mode != Mode.SCROLLING)
+            selected_entry.show_prompts ();
+
+        focus_prompt ();
+        redraw_greeter_box ();
+    }
+
+    public void add_user (string name, string label, string? background = null, bool is_active = false, bool has_messages = false, string? session = null)
+    {
+        var e = find_entry (name) as UserPromptBox;
+        if (e == null)
+        {
+            e = new UserPromptBox (name);
+            e.respond.connect (prompt_box_respond_cb);
+            e.login.connect (prompt_box_login_cb);
+            e.show_options.connect (prompt_box_show_options_cb);
+            e.label = label; /* Do this before adding for sorting purposes */
+            add_entry (e);
+        }
+        e.background = background;
+        e.is_active = is_active;
+        e.session = session;
+        e.label = label;
+        e.set_show_message_icon (has_messages);
+        e.set_is_active (is_active);
+
+        /* Remove manual option when have users */
+        if (have_entries () && !always_show_manual)
+            remove_entry ("*other");
+    }
+
+    protected override void add_manual_entry ()
+    {
+        var text = manual_name;
+        if (text == null)
+            text = _("Login");
+        add_user ("*other", text);
+    }
+
+    protected void prompt_box_respond_cb (string[] responses)
+    {
+        selected_entry.sensitive = false;
+        will_clear = true;
+        unacknowledged_messages = false;
+
+        foreach (var response in responses)
+        {
+            if (UnityGreeter.singleton.test_mode)
+                test_respond (response);
+            else
+                UnityGreeter.singleton.respond (response);
+        }
+    }
+
+    private void prompt_box_login_cb ()
+    {
+        debug ("Start session for %s", selected_entry.id);
+
+        unacknowledged_messages = false;
+        var is_authenticated = false;
+        if (UnityGreeter.singleton.test_mode)
+            is_authenticated = test_is_authenticated;
+        else
+            is_authenticated = UnityGreeter.singleton.is_authenticated();
+
+        /* Finish authentication (again) or restart it */
+        if (is_authenticated)
+            authentication_complete_cb ();
+        else
+        {
+            selected_entry.clear ();
+            start_authentication ();
+        }
+    }
+
+    private void prompt_box_show_options_cb ()
+    {
+        var session_chooser = new SessionList (background, menubar, session, default_session);
+        session_chooser.session_clicked.connect (session_clicked_cb);
+        UnityGreeter.singleton.push_list (session_chooser);
+    }
+
+    private void session_clicked_cb (string session)
+    {
+        this.session = session;
+        UnityGreeter.singleton.pop_list ();
+    }
+
+    private bool should_show_session_badge ()
+    {
+        if (UnityGreeter.singleton.test_mode)
+            return get_selected_id () != "no-badge";
+        else
+            return LightDM.get_sessions ().length () > 1;
+    }
+
+    private Gdk.Pixbuf? get_badge ()
+    {
+        if (selected_entry is UserPromptBox)
+        {
+            if (!should_show_session_badge ())
+                return null;
+            else if (session == null)
+                return SessionList.get_badge (default_session);
+            else
+                return SessionList.get_badge (session);
+        }
+        else
+        {
+            if (selected_entry.id.has_prefix ("*remote_directory"))
+                return SessionList.get_badge ("remote-login");
+            else
+                return null;
+        }
+    }
+
+    private bool is_supported_remote_session (string session_internal_name)
+    {
+        if (UnityGreeter.singleton.test_mode)
+            return session_internal_name == "rdp";
+
+        var found = false;
+        foreach (var session in LightDM.get_remote_sessions ())
+        {
+            if (session.key == session_internal_name)
+            {
+                found = true;
+                break;
+            }
+        }
+        return found;
+    }
+
+    protected override string get_lightdm_session ()
+    {
+        if (selected_entry.id.has_prefix ("*remote_login"))
+        {
+            var url = url_from_remote_loding_server_list_name (selected_entry.id);
+            unowned List<RemoteServer?> it = remote_login_server_list;
+
+            var answer = "";
+            while (answer == "" && it != null)
+            {
+                RemoteServer remote_server = it.data;
+                if (remote_server.url == url)
+                    answer = remote_server.type;
+                it = it.next;
+            }
+
+            if (is_supported_remote_session (answer))
+                return answer;
+            else
+                return "";
+        }
+        else
+            return session;
+    }
+
+    private void fill_list ()
+    {
+        if (UnityGreeter.singleton.test_mode)
+            test_fill_list ();
+        else
+        {
+            default_session = UnityGreeter.singleton.default_session_hint ();
+            always_show_manual = UnityGreeter.singleton.show_manual_login_hint ();
+            if (!UnityGreeter.singleton.hide_users_hint ())
+            {
+                var users = LightDM.UserList.get_instance ();
+                users.user_added.connect (user_added_cb);
+                users.user_changed.connect (user_added_cb);
+                users.user_removed.connect (user_removed_cb);
+                foreach (var user in users.users)
+                    user_added_cb (user);
+            }
+
+            if (UnityGreeter.singleton.has_guest_account_hint ())
+            {
+                debug ("Adding guest account entry");
+                offer_guest = true;
+            }
+
+            /* If we have no entries at all, we should show manual */
+            if (!have_entries ())
+                add_manual_entry ();
+
+            var last_user = UnityGreeter.singleton.get_state ("last-user");
+            if (UnityGreeter.singleton.select_user_hint () != null)
+                set_active_entry (UnityGreeter.singleton.select_user_hint ());
+            else if (last_user != null)
+                set_active_entry (last_user);
+        }
+    }
+
+    private void user_added_cb (LightDM.User user)
+    {
+        debug ("Adding/updating user %s (%s)", user.name, user.real_name);
+
+        if (!show_hidden_users)
+        {
+            var hidden_users = UGSettings.get_strv (UGSettings.KEY_HIDDEN_USERS);
+            foreach (var username in hidden_users)
+                if (username == user.name)
+                    return;
+        }
+
+        var label = user.real_name;
+        if (user.real_name == "")
+            label = user.name;
+
+        add_user (user.name, label, user.background, user.logged_in, user.has_messages, user.session);
+    }
+
+    private void user_removed_cb (LightDM.User user)
+    {
+        debug ("Removing user %s", user.name);
+        remove_entry (user.name);
+    }
+
+    protected override void show_prompt_cb (string text, LightDM.PromptType type)
+    {
+        if (selected_entry.id.has_prefix ("*remote_login"))
+        {
+            if (text == "remote login:")
+            {
+                Gtk.Entry field = current_remote_fields.get ("username") as Gtk.Entry;
+                var answer = field != null ? field.text : "";
+                UnityGreeter.singleton.respond (answer);
+            }
+            else if (text == "password:")
+            {
+                Gtk.Entry field = current_remote_fields.get ("password") as Gtk.Entry;
+                var answer = field != null ? field.text : "";
+                UnityGreeter.singleton.respond (answer);
+            }
+            else if (text == "remote host:")
+            {
+                var answer = url_from_remote_loding_server_list_name (selected_entry.id);
+                UnityGreeter.singleton.respond (answer);
+            }
+            else if (text == "domain:")
+            {
+                Gtk.Entry field = current_remote_fields.get ("domain") as Gtk.Entry;
+                var answer = field != null ? field.text : "";
+                UnityGreeter.singleton.respond (answer);
+            }
+        }
+        else
+            base.show_prompt_cb (text, type);
+    }
+
+    /* A lot of test code below here */
+
+    private struct TestEntry
+    {
+        string username;
+        string real_name;
+        string? background;
+        bool is_active;
+        bool has_messages;
+        string? session;
+    }
+
+    private const TestEntry[] test_entries =
+    {
+        { "has-password",       "Has Password",      "*" },
+        { "different-prompt",   "Different Prompt",  "*" },
+        { "no-password",        "No Password",       "*" },
+        { "change-password",    "Change Password",   "*" },
+        { "auth-error",         "Auth Error",        "*" },
+        { "two-factor",         "Two Factor",        "*" },
+        { "two-prompts",        "Two Prompts",       "*" },
+        { "info-prompt",        "Info Prompt",       "*" },
+        { "long-info-prompt",   "Long Info Prompt",  "*" },
+        { "wide-info-prompt",   "Wide Info Prompt",  "*" },
+        { "multi-info-prompt",  "Multi Info Prompt", "*" },
+        { "very-very-long-name",    "Long name (far far too long to fit)", "*" },
+        { "long-name-and-messages", "Long name and messages (too long to fit)", "*", false, true },
+        { "active",             "Active Account",    "*", true },
+        { "has-messages",       "Has Messages",      "*", false, true },
+        { "gnome",              "GNOME",             "*", false, false, "gnome" },
+        { "locked",             "Locked Account",    "*" },
+        { "color-background",   "Color Background",  "#dd4814" },
+        { "white-background",   "White Background",  "#ffffff" },
+        { "black-background",   "Black Background",  "#000000" },
+        { "no-background",      "No Background",     null },
+        { "unicode",            "가나다라마",         "*" },
+        { "no-response",        "No Response",       "*" },
+        { "no-badge",           "No Badge",          "*" },
+        { "messages-after-login", "Messages After Login", "*" },
+        { "" }
+    };
+    private List<string> test_backgrounds;
+    private int n_test_entries = 0;
+    private bool test_prompted_sso = false;
+    private string test_two_prompts_first = null;
+    private bool test_request_new_password = false;
+    private string? test_new_password = null;
+
+    private void test_fill_list ()
+    {
+        test_backgrounds = new List<string> ();
+        try
+        {
+            var dir = Dir.open ("/usr/share/backgrounds/");
+            while (true)
+            {
+                var bg = dir.read_name ();
+                if (bg == null)
+                    break;
+                test_backgrounds.append ("/usr/share/backgrounds/" + bg);
+            }
+        }
+        catch (FileError e)
+        {
+        }
+
+        if (!UnityGreeter.singleton.hide_users_hint())
+            while (add_test_entry ());
+
+        /* add a manual entry if the list of entries is empty initially */
+        if (n_test_entries <= 0)
+        {
+            add_manual_entry();
+            set_active_entry ("*other");
+            n_test_entries++;
+        }
+
+        offer_guest = UnityGreeter.singleton.has_guest_account_hint();
+        always_show_manual = UnityGreeter.singleton.show_manual_login_hint();
+
+        key_press_event.connect (test_key_press_cb);
+
+        if (UnityGreeter.singleton.show_remote_login_hint())
+            Timeout.add (1000, () =>
+            {
+                RemoteServer[] test_server_list = {};
+                RemoteServer remote_server = RemoteServer ();
+                remote_server.type = "uccs";
+                remote_server.name = "Remote Login";
+                remote_server.url = "http://crazyurl.com";
+                remote_server.last_used_server = false;
+                remote_server.fields = {};
+                RemoteServerField field1 = RemoteServerField ();
+                field1.type = "email";
+                RemoteServerField field2 = RemoteServerField ();
+                field2.type = "password";
+                remote_server.fields = {field1, field2};
+                
+                test_server_list += remote_server;
+                set_remote_directory_servers (test_server_list);
+                
+                return false;
+            });
+
+        var last_user = UnityGreeter.singleton.get_state ("last-user");
+        if (last_user != null)
+            set_active_entry (last_user);
+
+    }
+
+    private void test_call_set_remote_directory_servers ()
+    {
+        RemoteServer[] test_server_list = {};
+        RemoteServer remote_server = RemoteServer ();
+        remote_server.type = "uccs";
+        remote_server.name = "Corporate Remote Login";
+        remote_server.url = "http://internalcompayserver.com";
+        remote_server.last_used_server = false;
+        remote_server.fields = {};
+        RemoteServerField field1 = RemoteServerField ();
+        field1.type = "email";
+        RemoteServerField field2 = RemoteServerField ();
+        field2.type = "password";
+        remote_server.fields = {field1, field2};
+
+        test_server_list += remote_server;
+        set_remote_directory_servers (test_server_list);
+    }
+
+    private void test_call_remote_login_servers_updated ()
+    {
+        RemoteServer[] server_list = {};
+        RemoteServer remote_server1 = RemoteServer ();
+        remote_server1.type = "rdp";
+        remote_server1.name = "Cool RDP server";
+        remote_server1.url = "http://coolrdpserver.com";
+        remote_server1.last_used_server = false;
+        remote_server1.fields = {};
+        RemoteServerField field1 = RemoteServerField ();
+        field1.type = "username";
+        RemoteServerField field2 = RemoteServerField ();
+        field2.type = "password";
+        RemoteServerField field3 = RemoteServerField ();
+        field3.type = "domain";
+        remote_server1.fields = {field1, field2, field3};
+
+        RemoteServer remote_server2 = RemoteServer ();
+        remote_server2.type = "rdp";
+        remote_server2.name = "MegaCool RDP server";
+        remote_server2.url = "http://megacoolrdpserver.com";
+        remote_server2.last_used_server = false;
+        remote_server2.fields = {};
+        RemoteServerField field21 = RemoteServerField ();
+        field21.type = "username";
+        RemoteServerField field22 = RemoteServerField ();
+        field22.type = "password";
+        remote_server2.fields = {field21, field22};
+
+        server_list.resize (2);
+        server_list[0] = remote_server1;
+        server_list[1] = remote_server2;
+
+        remote_login_servers_updated (currently_browsing_server_url, currently_browsing_server_email, "", server_list);
+    }
+
+    private void test_fill_remote_login_servers (out RemoteServer[] server_list)
+    {
+        string[] domains = { "SCANNERS", "PRINTERS", "ROUTERS" };
+
+        server_list = {};
+        RemoteServer remote_server1 = RemoteServer ();
+        remote_server1.type = "rdp";
+        remote_server1.name = "Cool RDP server";
+        remote_server1.url = "http://coolrdpserver.com";
+        remote_server1.last_used_server = false;
+        remote_server1.fields = {};
+        RemoteServerField field1 = RemoteServerField ();
+        field1.type = "username";
+        RemoteServerField field2 = RemoteServerField ();
+        field2.type = "password";
+        RemoteServerField field3 = RemoteServerField ();
+        field3.type = "domain";
+        remote_server1.fields = {field1, field2, field3};
+
+        RemoteServer remote_server2 = RemoteServer ();
+        remote_server2.type = "rdp";
+        remote_server2.name = "RDP server with default username, and editable domain";
+        remote_server2.url = "http://rdpdefaultusername.com";
+        remote_server2.last_used_server = false;
+        remote_server2.fields = {};
+        RemoteServerField field21 = RemoteServerField ();
+        field21.type = "username";
+        field21.default_value = new Variant.string ("alowl");
+        RemoteServerField field22 = RemoteServerField ();
+        field22.type = "password";
+        RemoteServerField field23 = RemoteServerField ();
+        field23.type = "domain";
+        field23.default_value = new Variant.string ("PRINTERS");
+        field23.properties = new HashTable<string, Variant> (str_hash, str_equal);
+        field23.properties["domains"] = domains;
+        remote_server2.fields = {field21, field22, field23};
+
+        RemoteServer remote_server3 = RemoteServer ();
+        remote_server3.type = "rdp";
+        remote_server3.name = "RDP server with default username, and non editable domain";
+        remote_server3.url = "http://rdpdefaultusername2.com";
+        remote_server3.last_used_server = true;
+        remote_server3.fields = {};
+        RemoteServerField field31 = RemoteServerField ();
+        field31.type = "username";
+        field31.default_value = new Variant.string ("lwola");
+        RemoteServerField field32 = RemoteServerField ();
+        field32.type = "password";
+        RemoteServerField field33 = RemoteServerField ();
+        field33.type = "domain";
+        field33.default_value = new Variant.string ("PRINTERS");
+        field33.properties = new HashTable<string, Variant> (str_hash, str_equal);
+        field33.properties["domains"] = domains;
+        field33.properties["read-only"] = true;
+
+        remote_server3.fields = {field31, field32, field33};
+
+        RemoteServer remote_server4 = RemoteServer ();
+        remote_server4.type = "notsupported";
+        remote_server4.name = "Not supported server";
+        remote_server4.url = "http://notsupportedserver.com";
+        remote_server4.fields = {};
+        RemoteServerField field41 = RemoteServerField ();
+        field41.type = "username";
+        RemoteServerField field42 = RemoteServerField ();
+        field42.type = "password";
+        RemoteServerField field43 = RemoteServerField ();
+        field43.type = "domain";
+
+        remote_server4.fields = {field41, field42, field43};
+
+        server_list.resize (4);
+        server_list[0] = remote_server1;
+        server_list[1] = remote_server2;
+        server_list[2] = remote_server3;
+        server_list[3] = remote_server4;
+    }
+
+    private void test_fill_remote_login_servers_duplicate_entries (out RemoteServer[] server_list)
+    {
+        /* Create two remote servers with same url but different username and domain. */
+        server_list = {};
+
+        RemoteServer remote_server2 = RemoteServer ();
+        remote_server2.type = "rdp";
+        remote_server2.name = "RDP server with default username, and editable domain";
+        remote_server2.url = "http://rdpdefaultusername.com";
+        remote_server2.last_used_server = false;
+        remote_server2.fields = {};
+        RemoteServerField field21 = RemoteServerField ();
+        field21.type = "username";
+        field21.default_value = new Variant.string ("alowl1");
+        RemoteServerField field22 = RemoteServerField ();
+        field22.type = "password";
+        field22.default_value = new Variant.string ("duplicate1");
+        RemoteServerField field23 = RemoteServerField ();
+        field23.type = "domain";
+        field23.default_value = new Variant.string ("SCANNERS");
+        remote_server2.fields = {field21, field22, field23};
+
+        RemoteServer remote_server5 = RemoteServer ();
+        remote_server5.type = "rdp";
+        remote_server5.name = "RDP server with default username, and editable domain";
+        remote_server5.url = "http://rdpdefaultusername.com";
+        remote_server5.last_used_server = false;
+        remote_server5.fields = {};
+        RemoteServerField field51 = RemoteServerField ();
+        field51.type = "username";
+        field51.default_value = new Variant.string ("alowl2");
+        RemoteServerField field52 = RemoteServerField ();
+        field52.type = "password";
+        field52.default_value = new Variant.string ("duplicate2");
+        RemoteServerField field53 = RemoteServerField ();
+        field53.type = "domain";
+        field53.default_value = new Variant.string ("PRINTERS");
+        remote_server5.fields = {field51, field52, field53};
+
+        server_list.resize (2);
+        server_list[0] = remote_server2;
+        server_list[1] = remote_server5;
+    }
+    
+    private bool test_key_press_cb (Gdk.EventKey event)
+    {
+        if ((event.state & Gdk.ModifierType.CONTROL_MASK) == 0)
+            return false;
+
+        switch (event.keyval)
+        {
+        case Gdk.Key.plus:
+            add_test_entry ();
+            break;
+        case Gdk.Key.minus:
+            remove_test_entry ();
+            break;
+        case Gdk.Key.@0:
+            while (remove_test_entry ());
+            offer_guest = false;
+            break;
+        case Gdk.Key.equal:
+            while (add_test_entry ());
+            offer_guest = true;
+            break;
+        case Gdk.Key.g:
+            offer_guest = false;
+            break;
+        case Gdk.Key.G:
+            offer_guest = true;
+            break;
+        case Gdk.Key.m:
+            always_show_manual = false;
+            break;
+        case Gdk.Key.M:
+            always_show_manual = true;
+            break;
+        }
+
+        return false;
+    }
+
+    private bool add_test_entry ()
+    {
+        var e = test_entries[n_test_entries];
+        if (e.username == "")
+            return false;
+
+        var background = e.background;
+        if (background == "*")
+        {
+            var background_index = 0;
+            for (var i = 0; i < n_test_entries; i++)
+            {
+                if (test_entries[i].background == "*")
+                    background_index++;
+            }
+            if (test_backgrounds.length () > 0)
+                background = test_backgrounds.nth_data (background_index % test_backgrounds.length ());
+        }
+        add_user (e.username, e.real_name, background, e.is_active, e.has_messages, e.session);
+        n_test_entries++;
+
+        return true;
+    }
+
+    private bool remove_test_entry ()
+    {
+        if (n_test_entries == 0)
+            return false;
+
+        remove_entry (test_entries[n_test_entries - 1].username);
+        n_test_entries--;
+
+        return true;
+    }
+
+    private void test_respond (string text)
+    {
+        debug ("response %s", text);
+        switch (get_selected_id ())
+        {
+        case "*other":
+            if (test_username == null)
+            {
+                debug ("username=%s", text);
+                test_username = text;
+                show_prompt_cb ("Password:", LightDM.PromptType.SECRET);
+            }
+            else
+            {
+                test_is_authenticated = text == "password";
+                authentication_complete_cb ();
+            }
+            break;
+        case "two-factor":
+            if (!test_prompted_sso)
+            {
+                if (text == "password")
+                {
+                    debug ("prompt otp");
+                    test_prompted_sso = true;
+                    show_prompt_cb ("OTP:", LightDM.PromptType.QUESTION);
+                }
+                else
+                {
+                    test_is_authenticated = false;
+                    authentication_complete_cb ();
+                }
+            }
+            else
+            {
+                test_is_authenticated = text == "otp";
+                authentication_complete_cb ();
+            }
+            break;
+        case "two-prompts":
+            if (test_two_prompts_first == null)
+                test_two_prompts_first = text;
+            else
+            {
+                test_is_authenticated = test_two_prompts_first == "blue" && text == "password";
+                authentication_complete_cb ();
+            }
+            break;
+        case "change-password":
+            if (test_new_password != null)
+            {
+                test_is_authenticated = text == test_new_password;
+                authentication_complete_cb ();
+            }
+            else if (test_request_new_password)
+            {
+                test_new_password = text;
+                show_prompt_cb ("Retype new UNIX password: ", LightDM.PromptType.SECRET);
+            }
+            else
+            {
+                if (text != "password")
+                {
+                    test_is_authenticated = false;
+                    authentication_complete_cb ();
+                }
+                else
+                {
+                    test_request_new_password = true;
+                    show_message_cb ("You are required to change your password immediately (root enforced)", LightDM.MessageType.ERROR);
+                    show_prompt_cb ("Enter new UNIX password: ", LightDM.PromptType.SECRET);
+                }
+            }
+            break;
+        case "no-response":
+            break;
+        case "locked":
+            test_is_authenticated = false;
+            show_message_cb ("Account is locked", LightDM.MessageType.ERROR);
+            authentication_complete_cb ();
+            break;
+        case "messages-after-login":
+            test_is_authenticated = text == "password";
+            if (test_is_authenticated)
+                show_message_cb ("Congratulations on logging in!", LightDM.MessageType.INFO);
+            authentication_complete_cb ();
+            break;
+        default:
+            test_is_authenticated = text == "password";
+            authentication_complete_cb ();
+            break;
+        }
+    }
+
+    protected override void test_start_authentication ()
+    {
+        test_username = null;
+        test_is_authenticated = false;
+        test_prompted_sso = false;
+        test_two_prompts_first = null;
+        test_request_new_password = false;
+        test_new_password = null;
+
+        switch (get_selected_id ())
+        {
+        case "*other":
+            if (authenticate_user != null)
+            {
+                test_username = authenticate_user;
+                authenticate_user = null;
+                show_prompt_cb ("Password:", LightDM.PromptType.SECRET);
+            }
+            else
+                show_prompt_cb ("Username:", LightDM.PromptType.QUESTION);
+            break;
+        case "*guest":
+            test_is_authenticated = true;
+            authentication_complete_cb ();
+            break;
+        case "different-prompt":
+            show_prompt_cb ("Secret word", LightDM.PromptType.SECRET);
+            break;
+        case "no-password":
+            test_is_authenticated = true;
+            authentication_complete_cb ();
+            break;
+        case "auth-error":
+            show_message_cb ("Authentication Error", LightDM.MessageType.ERROR);
+            test_is_authenticated = false;
+            authentication_complete_cb ();
+            break;
+        case "info-prompt":
+            show_message_cb ("Welcome to Unity Greeter", LightDM.MessageType.INFO);
+            show_prompt_cb ("Password:", LightDM.PromptType.SECRET);
+            break;
+        case "long-info-prompt":
+            show_message_cb ("Welcome to Unity Greeter\n\nWe like to annoy you with long messages.\nLike this one\n\nThis is the last line of a multiple line message.", LightDM.MessageType.INFO);
+            show_prompt_cb ("Password:", LightDM.PromptType.SECRET);
+            break;
+        case "wide-info-prompt":
+            show_message_cb ("Welcome to Unity Greeter, the greeteriest greeter that ever did appear in these fine lands", LightDM.MessageType.INFO);
+            show_prompt_cb ("Password:", LightDM.PromptType.SECRET);
+            break;
+        case "multi-info-prompt":
+            show_message_cb ("Welcome to Unity Greeter", LightDM.MessageType.INFO);
+            show_message_cb ("This is an error", LightDM.MessageType.ERROR);
+            show_message_cb ("You should have seen three messages", LightDM.MessageType.INFO);
+            show_prompt_cb ("Password:", LightDM.PromptType.SECRET);
+            break;
+        case "two-prompts":
+            show_prompt_cb ("Favorite Color (blue):", LightDM.PromptType.QUESTION);
+            show_prompt_cb ("Password:", LightDM.PromptType.SECRET);
+            break;
+        default:
+            show_prompt_cb ("Password:", LightDM.PromptType.SECRET);
+            break;
+        }
+    }
+}