Store xsrf token received with psuggest results.

chrome/browser/autocomplete/search_provider.h

 // Copyright (c) 2012 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.
 //
 // This file contains the Search autocomplete provider.  This provider is
 // responsible for all autocomplete entries that start with "Search <engine>
 // for ...", including searching for the current input string, search
 // history, and search suggestions.  An instance of it gets created and
 // managed by the autocomplete controller.
 
 #ifndef CHROME_BROWSER_AUTOCOMPLETE_SEARCH_PROVIDER_H_
 #define CHROME_BROWSER_AUTOCOMPLETE_SEARCH_PROVIDER_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/scoped_vector.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "chrome/browser/autocomplete/autocomplete_input.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
 #include "chrome/browser/autocomplete/autocomplete_provider.h"
 #include "chrome/browser/history/history_types.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "net/url_request/url_fetcher_delegate.h"
 
 class Profile;
 class SearchProviderTest;
+class SuggestionDeletionHandler;
 class TemplateURLService;
 
 namespace base {
 class Value;
 }
 
 namespace net {
 class URLFetcher;
 }
 
 // Autocomplete provider for searches and suggestions from a search engine.
 //
 // After construction, the autocomplete controller repeatedly calls Start()
 // with some user input, each time expecting to receive a small set of the best
 // matches (either synchronously or asynchronously).
 //
 // Initially the provider creates a match that searches for the current input
 // text.  It also starts a task to query the Suggest servers.  When that data
 // comes back, the provider creates and returns matches for the best
 // suggestions.
 class SearchProvider : public AutocompleteProvider,
                        public net::URLFetcherDelegate {
  public:
   // ID used in creating URLFetcher for default provider's suggest results.
   static const int kDefaultProviderURLFetcherID;
 
   // ID used in creating URLFetcher for keyword provider's suggest results.
   static const int kKeywordProviderURLFetcherID;
 
+  // ID used in creating URLFetcher for deleting suggestion results.
+  static const int kDeletionURLFetcherID;
+
   SearchProvider(AutocompleteProviderListener* listener, Profile* profile);
 
   // Returns an AutocompleteMatch with the given |autocomplete_provider|,
   // |relevance|, and |type|, which represents a search via |template_url| for
   // |query_string|.  If |template_url| is NULL, returns a match with an invalid
   // destination URL.
   //
   // |input_text| is the original user input, which may differ from
   // |query_string|; e.g. the user typed "foo" and got a search suggestion of
   // "food", which we're now marking up.  This is used to highlight portions of
@@ skipping 25 matching lines @@
   // Returns whether the SearchProvider previously flagged |match| as a query
   // that should be prefetched.
   static bool ShouldPrefetch(const AutocompleteMatch& match);
 
   // Extracts the suggest response metadata which SearchProvider previously
   // stored for |match|.
   static std::string GetSuggestMetadata(const AutocompleteMatch& match);
 
   // AutocompleteProvider:
   virtual void AddProviderInfo(ProvidersInfo* provider_info) const OVERRIDE;
+  virtual void DeleteMatch(const AutocompleteMatch& match) OVERRIDE;
   virtual void ResetSession() OVERRIDE;
 
   bool field_trial_triggered_in_session() const {
     return field_trial_triggered_in_session_;
   }
 
   // This URL may be sent with suggest requests; see comments on CanSendURL().
   void set_current_page_url(const GURL& current_page_url) {
     current_page_url_ = current_page_url;
   }
 
+ protected:
+  virtual ~SearchProvider();
+
  private:
   // TODO(hfung): Remove ZeroSuggestProvider as a friend class after
   // refactoring common code to a new base class.
   friend class SearchProviderTest;
   friend class ZeroSuggestProvider;
   FRIEND_TEST_ALL_PREFIXES(SearchProviderTest, CanSendURL);
   FRIEND_TEST_ALL_PREFIXES(SearchProviderTest, NavigationInline);
   FRIEND_TEST_ALL_PREFIXES(SearchProviderTest, NavigationInlineDomainClassify);
   FRIEND_TEST_ALL_PREFIXES(SearchProviderTest, NavigationInlineSchemeSubstring);
   FRIEND_TEST_ALL_PREFIXES(SearchProviderTest, RemoveStaleResultsTest);
   FRIEND_TEST_ALL_PREFIXES(SearchProviderTest, SuggestRelevanceExperiment);
+  FRIEND_TEST_ALL_PREFIXES(SearchProviderTest,
+                           TestDeleteMatch_HasDeletionUrlSuccess);
+  FRIEND_TEST_ALL_PREFIXES(SearchProviderTest,
+                           TestDeleteMatch_HasDeletionUrlFailure);
   FRIEND_TEST_ALL_PREFIXES(AutocompleteProviderTest, GetDestinationURL);
   FRIEND_TEST_ALL_PREFIXES(InstantExtendedPrefetchTest, ClearPrefetchedResults);
   FRIEND_TEST_ALL_PREFIXES(InstantExtendedPrefetchTest, SetPrefetchQuery);
 
   // Manages the providers (TemplateURLs) used by SearchProvider. Two providers
   // may be used:
   // . The default provider. This corresponds to the user's default search
   //   engine. This is always used, except for the rare case of no default
   //   engine.
   // . The keyword provider. This is used if the user has typed in a keyword.
@@ skipping 88 matching lines @@
     // there.
     bool relevance_from_server_;
   };
 
   class SuggestResult : public Result {
    public:
     SuggestResult(const string16& suggestion,
                   const string16& match_contents,
                   const string16& annotation,
                   const std::string& suggest_query_params,
+                  const std::string& deletion_url,
                   bool from_keyword_provider,
                   int relevance,
                   bool relevance_from_server,
                   bool should_prefetch);
     virtual ~SuggestResult();
 
     const string16& suggestion() const { return suggestion_; }
     const string16& match_contents() const { return match_contents_; }
     const string16& annotation() const { return annotation_; }
     const std::string& suggest_query_params() const {
       return suggest_query_params_;
     }
+    const std::string& deletion_url() const { return deletion_url_; }
     bool should_prefetch() const { return should_prefetch_; }
 
     // Result:
     virtual bool IsInlineable(const string16& input) const OVERRIDE;
     virtual int CalculateRelevance(
         const AutocompleteInput& input,
         bool keyword_provider_requested) const OVERRIDE;
 
    private:
     // The search terms to be used for this suggestion.
     string16 suggestion_;
 
     // The contents to be displayed in the autocomplete match.
     string16 match_contents_;
 
     // Optional annotation for the |match_contents_| for disambiguation.
     // This may be displayed in the autocomplete match contents, but is defined
     // separately to facilitate different formatting.
     string16 annotation_;
 
     // Optional additional parameters to be added to the search URL.
     std::string suggest_query_params_;
 
+    // Optional deletion URL provided with suggestions. Fetching this URL
+    // should result in some reasonable deletion behaviour on the server,
+    // e.g. deleting this term out of a user's server-side search history.
+    std::string deletion_url_;
+
     // Should this result be prefetched?
     bool should_prefetch_;
   };
 
   class NavigationResult : public Result {
    public:
     // |provider| is necessary to use StringForURLDisplay() in order to
     // compute |formatted_url_|.
     NavigationResult(const AutocompleteProvider& provider,
                      const GURL& url,
@@ skipping 25 matching lines @@
     string16 description_;
   };
 
   class CompareScoredResults;
 
   typedef std::vector<SuggestResult> SuggestResults;
   typedef std::vector<NavigationResult> NavigationResults;
   typedef std::vector<history::KeywordSearchTermVisit> HistoryResults;
   typedef std::pair<string16, std::string> MatchKey;
   typedef std::map<MatchKey, AutocompleteMatch> MatchMap;
+  typedef ScopedVector<SuggestionDeletionHandler> SuggestionDeletionHandlers;
 
   // A simple structure bundling most of the information (including
   // both SuggestResults and NavigationResults) returned by a call to
   // the suggest server.
   //
   // This has to be declared after the typedefs since it relies on some of them.
   struct Results {
     Results();
     ~Results();
 
@@ skipping 16 matching lines @@
     // suppresses the verbatim result.
     int verbatim_relevance;
 
     // The JSON metadata associated with this server response.
     std::string metadata;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Results);
   };
 
-  virtual ~SearchProvider();
-
   // Removes non-inlineable results until either the top result can inline
   // autocomplete the current input or verbatim outscores the top result.
   static void RemoveStaleResults(const string16& input,
                                  int verbatim_relevance,
                                  SuggestResults* suggest_results,
                                  NavigationResults* navigation_results);
 
   // Calculates the relevance score for the keyword verbatim result (if the
   // input matches one of the profile's keyword).
   static int CalculateRelevanceForKeywordVerbatim(AutocompleteInput::Type type,
                                                   bool prefer_keyword);
 
   // AutocompleteProvider:
   virtual void Start(const AutocompleteInput& input,
                      bool minimal_changes) OVERRIDE;
   virtual void Stop(bool clear_cached_results) OVERRIDE;
 
   // net::URLFetcherDelegate:
   virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
 
+  // This gets called when we have requested a suggestion deletion from the
+  // server to handle the results of the deletion.
+  void OnDeletionComplete(bool success,
+                          SuggestionDeletionHandler* handler);
+
+  // Records in UMA whether the deletion request resulted in success.

[Peter Kasting, 2013/12/03 00:33:51]

Nit: Maybe add "This is virtual so test code can override it to check that we
correctly handle the request result."

[Peter Kasting, 2013/12/03 01:47:50]

Did you decide this wasn't worth doing?

[Maria, 2013/12/03 01:55:20]

Done.

+  virtual void RecordDeletionResult(bool success);
+
+  // Removes the deleted match from the list of |matches_|.
+  void DeleteMatchFromMatches(const AutocompleteMatch& match);
+
   // Called when timer_ expires.
   void Run();
 
   // Runs the history query, if necessary. The history query is synchronous.
   // This does not update |done_|.
   void DoHistoryQuery(bool minimal_changes);
 
   // Determines whether an asynchronous subcomponent query should run for the
   // current input.  If so, starts it if necessary; otherwise stops it.
   // NOTE: This function does not update |done_|.  Callers must do so.
@@ skipping 96 matching lines @@
 
   // Calculates the relevance score for the verbatim result from the default
   // search engine *ignoring* whether the input is a keyword-based search
   // or not.  This function should only be used to determine the minimum
   // relevance score that the best result from this provider should have.
   // For normal use, prefer the above function.
   int CalculateRelevanceForVerbatimIgnoringKeywordModeState() const;
 
   // Gets the relevance score for the keyword verbatim result.
   // |relevance_from_server| is handled as in GetVerbatimRelevance().
-  // TODO(mpearson): Refactor so this duplication isn't necesary or
+  // TODO(mpearson): Refactor so this duplication isn't necessary or
   // restructure so one static function takes all the parameters it needs
   // (rather than looking at internal state).
   int GetKeywordVerbatimRelevance(bool* relevance_from_server) const;
 
   // |time| is the time at which this query was last seen.  |is_keyword|
   // indicates whether the results correspond to the keyword provider or default
   // provider. |use_aggressive_method| says whether this function can use a
   // method that gives high scores (1200+) rather than one that gives lower
   // scores.  When using the aggressive method, scores may exceed 1300
   // unless |prevent_search_history_inlining| is set.
@@ skipping 10 matching lines @@
                      bool relevance_from_server,
                      bool should_prefetch,
                      const std::string& metadata,
                      AutocompleteMatch::Type type,
                      bool is_keyword,
                      const string16& match_contents,
                      const string16& annotation,
                      const string16& query_string,
                      int accepted_suggestion,
                      const std::string& suggest_query_params,
+                     const std::string& deletion_url,
                      MatchMap* map);
 
   // Returns an AutocompleteMatch for a navigational suggestion.
   AutocompleteMatch NavigationToMatch(const NavigationResult& navigation);
 
   // Resets the scores of all |keyword_navigation_results_| matches to
   // be below that of the top keyword query match (the verbatim match
   // as expressed by |keyword_verbatim_relevance_| or keyword query
   // suggestions stored in |keyword_suggest_results_|).  If there
   // are no keyword suggestions and keyword verbatim is suppressed,
@@ skipping 44 matching lines @@
   // were server-provided using this key in the |additional_info| field.
   static const char kRelevanceFromServerKey[];
 
   // Indicates whether the server said a match should be prefetched.
   static const char kShouldPrefetchKey[];
 
   // Used to store metadata from the server response, which is needed for
   // prefetching.
   static const char kSuggestMetadataKey[];
 
+  // Used to store a deletion request url for server-provided suggestions.
+  static const char kDeletionUrlKey[];
+
   // These are the values for the above keys.
   static const char kTrue[];
   static const char kFalse[];
 
   // Maintains the TemplateURLs used.
   Providers providers_;
 
   // The user's input.
   AutocompleteInput input_;
 
@@ skipping 16 matching lines @@
   base::TimeTicks time_suggest_request_sent_;
 
   // Fetchers used to retrieve results for the keyword and default providers.
   scoped_ptr<net::URLFetcher> keyword_fetcher_;
   scoped_ptr<net::URLFetcher> default_fetcher_;
 
   // Results from the default and keyword search providers.
   Results default_results_;
   Results keyword_results_;
 
+  // Each deletion handler in this vector corresponds to an outstanding request
+  // that a server delete a personalized suggestion. Making this a ScopedVector
+  // causes us to auto-cancel all such requests on shutdown.
+  SuggestionDeletionHandlers deletion_handlers_;
+
   // Whether a field trial, if any, has triggered in the most recent
   // autocomplete query.  This field is set to false in Start() and may be set
   // to true if either the default provider or keyword provider has completed
   // and their corresponding suggest response contained
   // '"google:fieldtrialtriggered":true'.
   // If the autocomplete query has not returned, this field is set to false.
   bool field_trial_triggered_;
 
   // Same as above except that it is maintained across the current Omnibox
   // session.
   bool field_trial_triggered_in_session_;
 
   // If true, search history query suggestions will score low enough that
   // they will not be inlined.
   bool prevent_search_history_inlining_;
 
   GURL current_page_url_;
 
   DISALLOW_COPY_AND_ASSIGN(SearchProvider);
 };
 
 #endif  // CHROME_BROWSER_AUTOCOMPLETE_SEARCH_PROVIDER_H_