[Sync] Initial implementation of foreign sessions suggestions provider.

components/ntp_snippets/sessions/foreign_sessions_suggestions_provider.h

+// Copyright 2016 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_NTP_SNIPPETS_SESSIONS_FOREIGN_SESSIONS_SUGGESTIONS_PROVIDER_H_
+#define COMPONENTS_NTP_SNIPPETS_SESSIONS_FOREIGN_SESSIONS_SUGGESTIONS_PROVIDER_H_
+
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "base/macros.h"
+#include "components/ntp_snippets/category.h"
+#include "components/ntp_snippets/category_status.h"
+#include "components/ntp_snippets/content_suggestions_provider.h"
+#include "components/sync_sessions/synced_session.h"
+
+class PrefRegistrySimple;
+class PrefService;
+
+namespace sync_driver {
+class OpenTabsUIDelegate;
+}  // namespace sync_driver
+
+namespace ntp_snippets {
+
+// Provides content suggestions from foreign sessions.
+class ForeignSessionsSuggestionsProvider : public ContentSuggestionsProvider {
+ public:
+  // Simple interface to get OpenTabsUIDelegate on demand and on change.
+  class OpenTabsUIDelegateProvider {

[tschumann, 2016/09/16 13:33:20]

not feeling strongly, but IMO this doesn't have to be a nested class.
We can just move it out and save typing long names ;-)

[skym, 2016/09/16 18:18:49]

Done. I find I have a hard time understand if things like this should be nested
on not. On one hand, it seems pretty generic and isn't tied to directly to
ForeignSessionsSuggestionsProvider but it is a pretty niche interface. And
though it isn't used anywhere else, and if you wanted to start using it, you
wouldn't want to #include ...foreign_sessions_suggestions_provider.h to get it.
You'd move it out to somewhere shared.

[tschumann, 2016/09/17 15:52:56]

Exactly. I try to avoid nested classes unless they are an essential part of the
interface, like ContentSuggestionsProvider::Observer. If you don't need the
outer classes name/context to grasp the semantics of the inner class, then I
usually don't nest them. And if not, I'd think about the names again ;-) Another
slight benefit is that inner classes cannot be forward declared -- but my main
motivation is to reduce the dependencies between the types and save awkward long
type names ;-)

+   public:
+    typedef base::Callback<void(sync_driver::OpenTabsUIDelegate*)>
+        OnChangeWithDelegate;

[Marc Treib, 2016/09/16 12:26:48]

nit: I prefer
using OnChangeWithDelegate =
base::Callback<void(sync_driver::OpenTabsUIDelegate*)>;

[skym, 2016/09/16 18:18:49]

Done. And then removed in favor of base::Closure

+    virtual ~OpenTabsUIDelegateProvider() {}
+    virtual sync_driver::OpenTabsUIDelegate* GetOpenTabsUIDelegate() = 0;
+    virtual void SubscribeForForeignTabChange(
+        const OnChangeWithDelegate& callback) = 0;
+  };
+
+  ForeignSessionsSuggestionsProvider(
+      ContentSuggestionsProvider::Observer* observer,
+      CategoryFactory* category_factory,
+      std::unique_ptr<OpenTabsUIDelegateProvider> delegate_provider,
+      PrefService* pref_service);
+  ~ForeignSessionsSuggestionsProvider() override;
+
+  static void RegisterProfilePrefs(PrefRegistrySimple* registry);
+
+ private:
+  friend class ForeignSessionsSuggestionsProviderTest;
+
+  // ContentSuggestionsProvider implementation.
+  CategoryStatus GetCategoryStatus(Category category) override;
+  CategoryInfo GetCategoryInfo(Category category) override;
+  void DismissSuggestion(const std::string& suggestion_id) override;
+  void FetchSuggestionImage(const std::string& suggestion_id,
+                            const ImageFetchedCallback& callback) override;
+  void ClearHistory(
+      base::Time begin,
+      base::Time end,
+      const base::Callback<bool(const GURL& url)>& filter) override;
+  void ClearCachedSuggestions(Category category) override;
+  void GetDismissedSuggestionsForDebugging(
+      Category category,
+      const DismissedSuggestionsCallback& callback) override;
+  void ClearDismissedSuggestionsForDebugging(Category category) override;
+
+  void OnForeignTabChange(
+      sync_driver::OpenTabsUIDelegate* open_tabs_ui_delegate);
+  std::vector<ContentSuggestion> BuildSuggestions(
+      const std::vector<const sync_driver::SyncedSession*>& foreign_sessions);
+  ContentSuggestion BuildSuggestion(
+      const sync_driver::SyncedSession& session,
+      const sessions::SessionTab& tab,
+      const sessions::SerializedNavigationEntry& navigation);
+
+  CategoryStatus category_status_;
+  const Category provided_category_;
+  std::unique_ptr<OpenTabsUIDelegateProvider> delegate_provider_;
+  PrefService* pref_service_;
+
+  DISALLOW_COPY_AND_ASSIGN(ForeignSessionsSuggestionsProvider);
+};
+
+}  // namespace ntp_snippets
+
+#endif  // COMPONENTS_NTP_SNIPPETS_SESSIONS_FOREIGN_SESSIONS_SUGGESTIONS_PROVIDER_H_