Show human readable origin for Android apps

chrome/browser/extensions/api/passwords_private/passwords_private_apitest.cc

 // Copyright 2015 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 <stddef.h>
 
 #include <sstream>
 
 #include "base/command_line.h"
 #include "base/macros.h"
@@ skipping 15 matching lines @@
 namespace extensions {
 
 namespace {
 
 static const size_t kNumMocks = 3;
 static const int kNumCharactersInPassword = 10;
 static const char kPlaintextPassword[] = "plaintext";
 
 api::passwords_private::PasswordUiEntry CreateEntry(size_t num) {
   api::passwords_private::PasswordUiEntry entry;
-  std::stringstream ss;
-  ss << "http://test" << num << ".com";
-  entry.login_pair.origin_url = ss.str();
-  ss << "/login";
-  entry.link_url = ss.str();
-  ss.clear();
-  ss << "testName" << num;
-  entry.login_pair.username = ss.str();
+  entry.login_pair.urls.shown = "test" + std::to_string(num) + ".com";
+  entry.login_pair.urls.origin =
+      "http://" + entry.login_pair.urls.shown + "/login";
+  entry.login_pair.urls.link = entry.login_pair.urls.origin;
+  entry.login_pair.username = "testName" + std::to_string(num);
   entry.num_characters_in_password = kNumCharactersInPassword;
   return entry;
 }
 
-api::passwords_private::ExceptionPair CreateException(size_t num) {
-  api::passwords_private::ExceptionPair exception;
-  std::stringstream ss;
-  ss << "http://exception" << num << ".com";
-  exception.exception_url = ss.str();
-  ss << "/login";
-  exception.link_url = ss.str();
+api::passwords_private::ExceptionEntry CreateException(size_t num) {
+  api::passwords_private::ExceptionEntry exception;
+  exception.urls.shown = "exception" + std::to_string(num) + ".com";
+  exception.urls.origin = "http://" + exception.urls.shown + "/login";
+  exception.urls.link = exception.urls.origin;
   return exception;
 }
 
 // A test PasswordsPrivateDelegate implementation which uses mock data.
 // TestDelegate starts out with kNumMocks mocks of each type (saved password
 // and password exception) and removes one mock each time RemoveSavedPassword()
 // or RemovePasswordException() is called.
 class TestDelegate : public PasswordsPrivateDelegate {
  public:
   TestDelegate() : profile_(nullptr) {
@@ skipping 17 matching lines @@
   }
 
   void SendPasswordExceptionsList() override {
     PasswordsPrivateEventRouter* router =
         PasswordsPrivateEventRouterFactory::GetForProfile(profile_);
     if (router)
       router->OnPasswordExceptionsListChanged(current_exceptions_);
   }
 
   void GetPasswordExceptionsList(
-      const ExceptionPairsCallback& callback) override {
+      const ExceptionEntriesCallback& callback) override {
     callback.Run(current_exceptions_);
   }
 
-  void RemoveSavedPassword(
-      const std::string& origin_url, const std::string& username) override {
+  void RemoveSavedPassword(const std::string& origin,
+                           const std::string& username) override {
     if (current_entries_.empty())
       return;
 
     // Since this is just mock data, remove the first entry regardless of
     // the data contained.
     current_entries_.erase(current_entries_.begin());
     SendSavedPasswordsList();
   }
 
   void RemovePasswordException(const std::string& exception_url) override {
     if (current_exceptions_.empty())
       return;
 
     // Since this is just mock data, remove the first entry regardless of
     // the data contained.
     current_exceptions_.erase(current_exceptions_.begin());
     SendPasswordExceptionsList();
   }
 
-  void RequestShowPassword(const std::string& origin_url,
+  void RequestShowPassword(const std::string& origin,
                            const std::string& username,
                            content::WebContents* web_contents) override {
     // Return a mocked password value.
     std::string plaintext_password(kPlaintextPassword);
     PasswordsPrivateEventRouter* router =
         PasswordsPrivateEventRouterFactory::GetForProfile(profile_);
     if (router) {
-      router->OnPlaintextPasswordFetched(origin_url, username,
-                                         plaintext_password);
+      router->OnPlaintextPasswordFetched(origin, username, plaintext_password);
     }
   }
 
   void SetProfile(Profile* profile) { profile_ = profile; }
 
  private:
   // The current list of entries/exceptions. Cached here so that when new
   // observers are added, this delegate can send the current lists without
   // having to request them from |password_manager_presenter_| again.
   std::vector<api::passwords_private::PasswordUiEntry> current_entries_;
-  std::vector<api::passwords_private::ExceptionPair> current_exceptions_;
+  std::vector<api::passwords_private::ExceptionEntry> current_exceptions_;
   Profile* profile_;
 };
 
 class PasswordsPrivateApiTest : public ExtensionApiTest {
  public:
   PasswordsPrivateApiTest() {
     if (!s_test_delegate_) {
       s_test_delegate_ = new TestDelegate();
     }
   }
@@ skipping 53 matching lines @@
 
 IN_PROC_BROWSER_TEST_F(PasswordsPrivateApiTest, GetSavedPasswordList) {
   EXPECT_TRUE(RunPasswordsSubtest("getSavedPasswordList")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(PasswordsPrivateApiTest, GetPasswordExceptionList) {
   EXPECT_TRUE(RunPasswordsSubtest("getPasswordExceptionList")) << message_;
 }
 
 }  // namespace extensions