[NTP Snippets] Introduce ContentSuggestion::ID

components/ntp_snippets/content_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_CONTENT_SUGGESTIONS_PROVIDER_H_
 #define COMPONENTS_NTP_SNIPPETS_CONTENT_SUGGESTIONS_PROVIDER_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 52 matching lines @@
     // registered.
     virtual void OnCategoryStatusChanged(ContentSuggestionsProvider* provider,
                                          Category category,
                                          CategoryStatus new_status) = 0;
 
     // Called when a suggestion has been invalidated. It will not be provided
     // through |OnNewSuggestions| anymore, is not supported by
     // |FetchSuggestionImage| or |DismissSuggestion| anymore, and should
     // immediately be cleared from the UI and caches. This happens, for example,
     // when the content that the suggestion refers to is gone.
-    // Note that this event may be fired even if the corresponding |category| is
+    // Note that this event may be fired even if the corresponding category is
     // not currently AVAILABLE, because open UIs may still be showing the
     // suggestion that is to be removed. This event may also be fired for
     // |suggestion_id|s that never existed and should be ignored in that case.
-    virtual void OnSuggestionInvalidated(ContentSuggestionsProvider* provider,
-                                         Category category,
-                                         const std::string& suggestion_id) = 0;
+    virtual void OnSuggestionInvalidated(
+        ContentSuggestionsProvider* provider,
+        const ContentSuggestion::ID& suggestion_id) = 0;
   };
 
   virtual ~ContentSuggestionsProvider();
 
   // Determines the status of the given |category|, see CategoryStatus.
   virtual CategoryStatus GetCategoryStatus(Category category) = 0;
 
   // Returns the meta information for the given |category|.
   virtual CategoryInfo GetCategoryInfo(Category category) = 0;
 
   // Dismisses the suggestion with the given ID. A provider needs to ensure that
   // a once-dismissed suggestion is never delivered again (through the
   // Observer). The provider must not call Observer::OnSuggestionsChanged if the
   // removal of the dismissed suggestion is the only change.
-  virtual void DismissSuggestion(const std::string& suggestion_id) = 0;
+  virtual void DismissSuggestion(
+      const ContentSuggestion::ID& suggestion_id) = 0;
 
   // Fetches the image for the suggestion with the given ID and returns it
   // through the callback. This fetch may occur locally or from the internet.
   // If that suggestion doesn't exist, doesn't have an image or if the fetch
   // fails, the callback gets a null image. The callback will not be called
   // synchronously.
-  virtual void FetchSuggestionImage(const std::string& suggestion_id,
+  virtual void FetchSuggestionImage(const ContentSuggestion::ID& suggestion_id,
                                     const ImageFetchedCallback& callback) = 0;
 
   // Removes history from the specified time range where the URL matches the
   // |filter|. The data removed depends on the provider. Note that the
   // data outside the time range may be deleted, for example suggestions, which
   // are based on history from that time range. Providers should immediately
   // clear any data related to history from the specified time range where the
   // URL matches the |filter|.
   virtual void ClearHistory(
       base::Time begin,
@@ skipping 17 matching lines @@
   // suggestions for the given |category|, if present, so that no suggestions
   // are suppressed. This does not necessarily make previously dismissed
   // suggestions reappear, as they may have been permanently deleted, depending
   // on the provider implementation.
   virtual void ClearDismissedSuggestionsForDebugging(Category category) = 0;
 
  protected:
   ContentSuggestionsProvider(Observer* observer,
                              CategoryFactory* category_factory);
 
-  // Creates a unique ID. The given |within_category_id| must be unique among
-  // all suggestion IDs from this provider for the given |category|. This method
-  // combines it with the |category| to form an ID that is unique
-  // application-wide, because this provider is the only one that provides
-  // suggestions for that category.
-  std::string MakeUniqueID(Category category,
-                           const std::string& within_category_id) const;
-
-  // Reverse functions for MakeUniqueID()
-  Category GetCategoryFromUniqueID(const std::string& unique_id) const;
-  std::string GetWithinCategoryIDFromUniqueID(
-      const std::string& unique_id) const;
-
   Observer* observer() const { return observer_; }
   CategoryFactory* category_factory() const { return category_factory_; }
 
  private:
   Observer* observer_;
   CategoryFactory* category_factory_;
 };
 
 }  // namespace ntp_snippets
 
 #endif  // COMPONENTS_NTP_SNIPPETS_CONTENT_SUGGESTIONS_PROVIDER_H_