Do not build Password Reuse on Android and iOS

components/password_manager/core/browser/password_store.h

 // Copyright 2014 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.
 
 #ifndef COMPONENTS_PASSWORD_MANAGER_CORE_BROWSER_PASSWORD_STORE_H_
 #define COMPONENTS_PASSWORD_MANAGER_CORE_BROWSER_PASSWORD_STORE_H_
 
 #include <memory>
 #include <ostream>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/observer_list_threadsafe.h"
 #include "base/single_thread_task_runner.h"
 #include "base/time/time.h"
 #include "components/keyed_service/core/refcounted_keyed_service.h"
-#include "components/password_manager/core/browser/password_reuse_detector.h"
-#include "components/password_manager/core/browser/password_reuse_detector_consumer.h"
 #include "components/password_manager/core/browser/password_store_change.h"
 #include "components/password_manager/core/browser/password_store_sync.h"
 #include "components/sync/model/syncable_service.h"
 
+// TODO(crbug.com/706392): Fix password reuse detection for Android.
+#if !defined(OS_ANDROID) && !defined(OS_IOS)
+#include "components/password_manager/core/browser/password_reuse_detector.h"
+#include "components/password_manager/core/browser/password_reuse_detector_consumer.h"
+#endif
+
 class PasswordStoreProxyMac;
 
 namespace autofill {
 struct PasswordForm;
 }
 
 namespace syncer {
 class SyncableService;
 }
 
@@ skipping 184 matching lines @@
   void AddObserver(Observer* observer);
 
   // Removes |observer| from the observer list.
   void RemoveObserver(Observer* observer);
 
   // Schedules the given |task| to be run on the PasswordStore's TaskRunner.
   bool ScheduleTask(const base::Closure& task);
 
   base::WeakPtr<syncer::SyncableService> GetPasswordSyncableService();
 
+// TODO(crbug.com/706392): Fix password reuse detection for Android.
+#if !defined(OS_ANDROID) && !defined(OS_IOS)
   // Checks that some suffix of |input| equals to a password saved on another
   // registry controlled domain than |domain|.
   // If such suffix is found, |consumer|->OnReuseFound() is called on the same
   // thread on which this method is called.
   // |consumer| must not be null.
   virtual void CheckReuse(const base::string16& input,
                           const std::string& domain,
                           PasswordReuseDetectorConsumer* consumer);
+#endif
 
  protected:
   friend class base::RefCountedThreadSafe<PasswordStore>;
 
   typedef base::Callback<PasswordStoreChangeList(void)> ModificationTask;
 
   // Represents a single GetLogins() request. Implements functionality to filter
   // results and send them to the consumer on the consumer's message loop.
   class GetLoginsRequest {
    public:
@@ skipping 16 matching lines @@
    private:
     // See GetLogins(). Logins older than this will be removed from the reply.
     base::Time ignore_logins_cutoff_;
 
     scoped_refptr<base::SingleThreadTaskRunner> origin_task_runner_;
     base::WeakPtr<PasswordStoreConsumer> consumer_weak_;
 
     DISALLOW_COPY_AND_ASSIGN(GetLoginsRequest);
   };
 
+// TODO(crbug.com/706392): Fix password reuse detection for Android.
+#if !defined(OS_ANDROID) && !defined(OS_IOS)
   // Represents a single CheckReuse() request. Implements functionality to
   // listen to reuse events and propagate them to |consumer| on the thread on
   // which CheckReuseRequest is created.
   class CheckReuseRequest : public PasswordReuseDetectorConsumer {
    public:
     // |consumer| must not be null.
     explicit CheckReuseRequest(PasswordReuseDetectorConsumer* consumer);
     ~CheckReuseRequest() override;
 
     // PasswordReuseDetectorConsumer
     void OnReuseFound(const base::string16& password,
                       const std::string& saved_domain,
                       int saved_passwords,
                       int number_matches) override;
 
    private:
     const scoped_refptr<base::SingleThreadTaskRunner> origin_task_runner_;
     const base::WeakPtr<PasswordReuseDetectorConsumer> consumer_weak_;
 
     DISALLOW_COPY_AND_ASSIGN(CheckReuseRequest);
   };
+#endif
 
   ~PasswordStore() override;
 
   // Get the TaskRunner to use for PasswordStore background tasks.
   // By default, a SingleThreadTaskRunner on the DB thread is used, but
   // subclasses can override.
   virtual scoped_refptr<base::SingleThreadTaskRunner> GetBackgroundTaskRunner();
 
   // Methods below will be run in PasswordStore's own thread.
   // Synchronous implementation that reports usage metrics.
@@ skipping 74 matching lines @@
   PasswordStoreChangeList UpdateLoginSync(
       const autofill::PasswordForm& form) override;
   PasswordStoreChangeList RemoveLoginSync(
       const autofill::PasswordForm& form) override;
 
   // Called by WrapModificationTask() once the underlying data-modifying
   // operation has been performed. Notifies observers that password store data
   // may have been changed.
   void NotifyLoginsChanged(const PasswordStoreChangeList& changes) override;
 
+// TODO(crbug.com/706392): Fix password reuse detection for Android.
+#if !defined(OS_ANDROID) && !defined(OS_IOS)
   // Synchronous implementation of CheckReuse().
   void CheckReuseImpl(std::unique_ptr<CheckReuseRequest> request,
                       const base::string16& input,
                       const std::string& domain);
+#endif
 
   // TaskRunner for tasks that run on the main thread (usually the UI thread).
   scoped_refptr<base::SingleThreadTaskRunner> main_thread_runner_;
 
   // TaskRunner for the DB thread. By default, this is the task runner used for
   // background tasks -- see |GetBackgroundTaskRunner|.
   scoped_refptr<base::SingleThreadTaskRunner> db_thread_runner_;
 
  private:
   FRIEND_TEST_ALL_PREFIXES(PasswordStoreTest, GetLoginImpl);
@@ skipping 131 matching lines @@
       const syncer::SyncableService::StartSyncFlare& flare);
 
   // Deletes objest that should be destroyed on the background thread.
   void DestroyOnBackgroundThread();
 
   // The observers.
   scoped_refptr<base::ObserverListThreadSafe<Observer>> observers_;
 
   std::unique_ptr<PasswordSyncableService> syncable_service_;
   std::unique_ptr<AffiliatedMatchHelper> affiliated_match_helper_;
+// TODO(crbug.com/706392): Fix password reuse detection for Android.
+#if !defined(OS_ANDROID) && !defined(OS_IOS)
   std::unique_ptr<PasswordReuseDetector> reuse_detector_;
+#endif
   bool is_propagating_password_changes_to_web_credentials_enabled_;
 
   bool shutdown_called_;
 
   DISALLOW_COPY_AND_ASSIGN(PasswordStore);
 };
 
 // For logging only.
 std::ostream& operator<<(std::ostream& os,
                          const PasswordStore::FormDigest& digest);
 
 }  // namespace password_manager
 
 #endif  // COMPONENTS_PASSWORD_MANAGER_CORE_BROWSER_PASSWORD_STORE_H_