Home | History | Annotate | Download | only in options 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/ui/webui/options/password_manager_handler.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/prefs/pref_service.h"
      9 #include "base/strings/string_number_conversions.h"
     10 #include "base/strings/utf_string_conversions.h"
     11 #include "base/values.h"
     12 #include "chrome/browser/chrome_notification_types.h"
     13 #include "chrome/browser/profiles/profile.h"
     14 #if defined(OS_WIN) && defined(USE_ASH)
     15 #include "chrome/browser/ui/ash/ash_util.h"
     16 #endif
     17 #include "chrome/common/pref_names.h"
     18 #include "chrome/common/url_constants.h"
     19 #include "chrome/grit/generated_resources.h"
     20 #include "components/autofill/core/common/password_form.h"
     21 #include "content/public/browser/notification_details.h"
     22 #include "content/public/browser/notification_source.h"
     23 #include "content/public/browser/user_metrics.h"
     24 #include "content/public/browser/web_contents.h"
     25 #include "content/public/browser/web_ui.h"
     26 #include "net/base/net_util.h"
     27 
     28 namespace options {
     29 
     30 PasswordManagerHandler::PasswordManagerHandler()
     31     : password_manager_presenter_(this) {}
     32 
     33 PasswordManagerHandler::~PasswordManagerHandler() {}
     34 
     35 Profile* PasswordManagerHandler::GetProfile() {
     36   return Profile::FromWebUI(web_ui());
     37 }
     38 
     39 #if !defined(OS_ANDROID)
     40 gfx::NativeWindow PasswordManagerHandler::GetNativeWindow() {
     41   return web_ui()->GetWebContents()->GetTopLevelNativeWindow();
     42 }
     43 #endif
     44 
     45 void PasswordManagerHandler::GetLocalizedValues(
     46     base::DictionaryValue* localized_strings) {
     47   DCHECK(localized_strings);
     48 
     49   static const OptionsStringResource resources[] = {
     50     { "savedPasswordsTitle",
     51       IDS_PASSWORDS_SHOW_PASSWORDS_TAB_TITLE },
     52     { "passwordExceptionsTitle",
     53       IDS_PASSWORDS_EXCEPTIONS_TAB_TITLE },
     54     { "passwordSearchPlaceholder",
     55       IDS_PASSWORDS_PAGE_SEARCH_PASSWORDS },
     56     { "passwordShowButton",
     57       IDS_PASSWORDS_PAGE_VIEW_SHOW_BUTTON },
     58     { "passwordHideButton",
     59       IDS_PASSWORDS_PAGE_VIEW_HIDE_BUTTON },
     60     { "passwordsNoPasswordsDescription",
     61       IDS_PASSWORDS_PAGE_VIEW_NO_PASSWORDS_DESCRIPTION },
     62     { "passwordsNoExceptionsDescription",
     63       IDS_PASSWORDS_PAGE_VIEW_NO_EXCEPTIONS_DESCRIPTION },
     64   };
     65 
     66   RegisterStrings(localized_strings, resources, arraysize(resources));
     67   RegisterTitle(localized_strings, "passwordsPage",
     68                 IDS_PASSWORDS_EXCEPTIONS_WINDOW_TITLE);
     69 
     70   localized_strings->SetString("passwordManagerLearnMoreURL",
     71                                chrome::kPasswordManagerLearnMoreURL);
     72   bool disable_show_passwords = false;
     73 
     74 #if defined(OS_WIN) && defined(USE_ASH)
     75   // We disable the ability to show passwords when running in Windows Metro
     76   // interface.  This is because we cannot pop native Win32 dialogs from the
     77   // Metro process.
     78   // TODO(wfh): Revisit this if Metro usage grows.
     79   if (chrome::IsNativeWindowInAsh(GetNativeWindow()))
     80     disable_show_passwords = true;
     81 #endif
     82 
     83   localized_strings->SetBoolean("disableShowPasswords", disable_show_passwords);
     84 }
     85 
     86 void PasswordManagerHandler::RegisterMessages() {
     87   web_ui()->RegisterMessageCallback(
     88       "updatePasswordLists",
     89       base::Bind(&PasswordManagerHandler::HandleUpdatePasswordLists,
     90                  base::Unretained(this)));
     91   web_ui()->RegisterMessageCallback(
     92       "removeSavedPassword",
     93       base::Bind(&PasswordManagerHandler::HandleRemoveSavedPassword,
     94                  base::Unretained(this)));
     95   web_ui()->RegisterMessageCallback(
     96       "removePasswordException",
     97       base::Bind(&PasswordManagerHandler::HandleRemovePasswordException,
     98                  base::Unretained(this)));
     99   web_ui()->RegisterMessageCallback(
    100       "requestShowPassword",
    101       base::Bind(&PasswordManagerHandler::HandleRequestShowPassword,
    102                  base::Unretained(this)));
    103 }
    104 
    105 void PasswordManagerHandler::InitializeHandler() {
    106   password_manager_presenter_.Initialize();
    107 }
    108 
    109 void PasswordManagerHandler::HandleRemoveSavedPassword(
    110     const base::ListValue* args) {
    111   std::string string_value = base::UTF16ToUTF8(ExtractStringValue(args));
    112   int index;
    113   if (base::StringToInt(string_value, &index) && index >= 0) {
    114     password_manager_presenter_.RemoveSavedPassword(static_cast<size_t>(index));
    115   }
    116 }
    117 
    118 void PasswordManagerHandler::HandleRemovePasswordException(
    119     const base::ListValue* args) {
    120   std::string string_value = base::UTF16ToUTF8(ExtractStringValue(args));
    121   int index;
    122   if (base::StringToInt(string_value, &index) && index >= 0) {
    123     password_manager_presenter_.RemovePasswordException(
    124         static_cast<size_t>(index));
    125   }
    126 }
    127 
    128 void PasswordManagerHandler::HandleRequestShowPassword(
    129     const base::ListValue* args) {
    130   int index;
    131   if (!ExtractIntegerValue(args, &index))
    132     NOTREACHED();
    133 
    134   password_manager_presenter_.RequestShowPassword(static_cast<size_t>(index));
    135 }
    136 
    137 void PasswordManagerHandler::ShowPassword(
    138     size_t index,
    139     const base::string16& password_value) {
    140   // Call back the front end to reveal the password.
    141   web_ui()->CallJavascriptFunction(
    142       "PasswordManager.showPassword",
    143       base::FundamentalValue(static_cast<int>(index)),
    144       base::StringValue(password_value));
    145 }
    146 
    147 void PasswordManagerHandler::HandleUpdatePasswordLists(
    148     const base::ListValue* args) {
    149   password_manager_presenter_.UpdatePasswordLists();
    150 }
    151 
    152 void PasswordManagerHandler::SetPasswordList(
    153     const ScopedVector<autofill::PasswordForm>& password_list,
    154     bool show_passwords) {
    155   base::ListValue entries;
    156   languages_ = GetProfile()->GetPrefs()->GetString(prefs::kAcceptLanguages);
    157   base::string16 placeholder(base::ASCIIToUTF16("        "));
    158   for (size_t i = 0; i < password_list.size(); ++i) {
    159     base::ListValue* entry = new base::ListValue();
    160     entry->Append(new base::StringValue(net::FormatUrl(password_list[i]->origin,
    161                                                        languages_)));
    162     entry->Append(new base::StringValue(password_list[i]->username_value));
    163     if (show_passwords) {
    164       entry->Append(new base::StringValue(password_list[i]->password_value));
    165     } else {
    166       // Use a placeholder value with the same length as the password.
    167       entry->Append(new base::StringValue(
    168           base::string16(password_list[i]->password_value.length(), ' ')));
    169     }
    170     entries.Append(entry);
    171   }
    172 
    173   web_ui()->CallJavascriptFunction("PasswordManager.setSavedPasswordsList",
    174                                    entries);
    175 }
    176 
    177 void PasswordManagerHandler::SetPasswordExceptionList(
    178     const ScopedVector<autofill::PasswordForm>& password_exception_list) {
    179   base::ListValue entries;
    180   for (size_t i = 0; i < password_exception_list.size(); ++i) {
    181     entries.Append(new base::StringValue(
    182         net::FormatUrl(password_exception_list[i]->origin, languages_)));
    183   }
    184 
    185   web_ui()->CallJavascriptFunction("PasswordManager.setPasswordExceptionsList",
    186                                    entries);
    187 }
    188 
    189 }  // namespace options
    190