Remove MostVisitedSites => SupervisedUserService dep.

chrome/browser/android/ntp/most_visited_sites.h

 // Copyright 2013 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 CHROME_BROWSER_ANDROID_NTP_MOST_VISITED_SITES_H_
 #define CHROME_BROWSER_ANDROID_NTP_MOST_VISITED_SITES_H_
 
 #include <stddef.h>
 
 #include <memory>
@@ skipping 23 matching lines @@
 }
 
 namespace user_prefs {
 class PrefRegistrySyncable;
 }
 
 namespace variations {
 class VariationsService;
 }
 
+class Supervisor {
+ public:
+  struct Whitelist {
+    base::string16 title;
+    GURL entry_point;
+    base::FilePath large_icon_path;
+  };
+
+  class Observer {
+   public:
+    virtual void OnURLFilterChanged() {}
+
+   protected:
+    ~Observer() {}
+  };
+
+  virtual void AddObserver(Observer* observer) = 0;
+  virtual void RemoveObserver(Observer* observer) = 0;

[Marc Treib, 2016/05/06 13:24:11]

There'll only ever be one observer, namely the MostVisitedSites instance, right?
Then let's make that explicit.

[sfiera, 2016/05/06 15:48:35]

Done.

+  virtual SupervisedUserURLFilter* GetURLFilterForUIThread() = 0;

[Marc Treib, 2016/05/06 13:24:11]

Like this, you still have a dependency on SupervisedUserURLFilter. Fortunately,
it's only used to check if a given URL is blocked. So, make this
bool IsURLBlocked(const GURL&)
instead?

[sfiera, 2016/05/06 15:48:35]

Done.

+  virtual std::vector<Whitelist> whitelists() const = 0;
+
+ protected:
+  virtual ~Supervisor() {}
+};
+
+class SupervisedUserServiceSupervisor : public Supervisor {
+ public:
+  SupervisedUserServiceSupervisor(Profile* profile);
+
+  void AddObserver(Observer* observer) override;
+  void RemoveObserver(Observer* observer) override;
+  SupervisedUserURLFilter* GetURLFilterForUIThread() override;
+  std::vector<Supervisor::Whitelist> whitelists() const override;
+
+ private:
+  struct SUSObserver : public SupervisedUserServiceObserver {
+   public:
+    SUSObserver(SupervisedUserService* service, Supervisor::Observer* observer)
+        : observer_(observer),
+          scope_(this) {
+      scope_.Add(service);
+    }
+
+    void OnURLFilterChanged() override {
+      observer_->OnURLFilterChanged();
+    }
+
+   private:
+    Supervisor::Observer* observer_;
+    ScopedObserver<SupervisedUserService, SupervisedUserServiceObserver> scope_;
+  };
+
+  Profile* const profile_;
+  std::map<Supervisor::Observer*, std::unique_ptr<SUSObserver>>
+      observers_;
+};
+
 // Tracks the list of most visited sites and their thumbnails.
 //
 // Do not use, except from MostVisitedSitesBridge. The interface is in flux
 // while we are extracting the functionality of the Java class to make available
 // in C++.
 //
 // TODO(sfiera): finalize interface.
 class MostVisitedSites : public history::TopSitesObserver,
-                         public SupervisedUserServiceObserver {
+                         public Supervisor::Observer {
  public:
   struct Suggestion;
   using SuggestionsVector = std::vector<Suggestion>;
   using PopularSitesVector = std::vector<PopularSites::Site>;
 
   // The source of the Most Visited sites.
   enum MostVisitedSource { TOP_SITES, SUGGESTIONS_SERVICE, POPULAR, WHITELIST };
 
   // The observer to be notified when the list of most visited sites changes.
   class Observer {
@@ skipping 27 matching lines @@
     DISALLOW_COPY_AND_ASSIGN(Suggestion);
   };
 
   MostVisitedSites(PrefService* prefs,
                    const TemplateURLService* template_url_service,
                    variations::VariationsService* variations_service,
                    net::URLRequestContextGetter* download_context,
                    scoped_refptr<history::TopSites> top_sites,
                    suggestions::SuggestionsService* suggestions,
                    bool is_child_profile,
-                   Profile* profile);
+                   Supervisor* supervisor);
 
   ~MostVisitedSites() override;
 
   // Does not take ownership of |observer|, which must outlive this object and
   // must not be null.
   void SetMostVisitedURLsObserver(Observer* observer, int num_sites);
 
   using ThumbnailCallback = base::Callback<
       void(bool /* is_local_thumbnail */, const SkBitmap* /* bitmap */)>;
   void GetURLThumbnail(const GURL& url, const ThumbnailCallback& callback);
@@ skipping 104 matching lines @@
 
   // Records UMA histogram metrics related to the number of impressions.
   void RecordImpressionUMAMetrics();
 
   // history::TopSitesObserver implementation.
   void TopSitesLoaded(history::TopSites* top_sites) override;
   void TopSitesChanged(history::TopSites* top_sites,
                        ChangeReason change_reason) override;
 
   // The profile whose most visited sites will be queried.
-  Profile* profile_;
 
   PrefService* prefs_;
   const TemplateURLService* template_url_service_;
   variations::VariationsService* variations_service_;
   net::URLRequestContextGetter* download_context_;
   scoped_refptr<history::TopSites> top_sites_;
   suggestions::SuggestionsService* suggestions_service_;
+  Supervisor* supervisor_;
 
   // Children will not be shown popular sites as suggestions.
   // TODO(sfiera): enable/disable suggestions if the profile is marked or
   // unmarked as a child profile during the lifetime of the object. For now, it
   // doesn't matter, because a MostVisitedSites is instantiated for each NTP,
   // but a longer-lived object would need to update.
   bool is_child_profile_;
 
   Observer* observer_;
 
@@ skipping 24 matching lines @@
 
   SuggestionsVector current_suggestions_;
 
   // For callbacks may be run after destruction.
   base::WeakPtrFactory<MostVisitedSites> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MostVisitedSites);
 };
 
 #endif  // CHROME_BROWSER_ANDROID_NTP_MOST_VISITED_SITES_H_