src/chrome/browser/ui/webui/options/password_manager_handler.cc

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