[Hotword] Implement audio history pref accessing and setting.

chrome/browser/history/web_history_service.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.
 
 #ifndef CHROME_BROWSER_HISTORY_WEB_HISTORY_SERVICE_H_
 #define CHROME_BROWSER_HISTORY_WEB_HISTORY_SERVICE_H_
 
 #include <set>
 
 #include "base/memory/weak_ptr.h"
@@ skipping 20 matching lines @@
   // the entire state of the request. When an instance is destroyed, all
   // aspects of the request are cancelled.
   class Request {
    public:
     virtual ~Request();
 
     // Returns true if the request is "pending" (i.e., it has been started, but
     // is not yet been complete).
     virtual bool is_pending() = 0;
 
+    // Returns the response code received from the server, which will only be
+    // valid if the request succeeded.
+    virtual int response_code() = 0;

[sky, 2014/11/19 01:02:41]

We don't use unix_hacker_style for virtual methods.

[rpetterson, 2014/11/19 02:04:56]

I was following the pre-existing style (see is_pending()) above. Would you
prefer I change all of these functions throughout the file?

[sky, 2014/11/19 16:02:43]

Yes, but if you want to fix up the other feel free to do it later.

+
+    // Returns the contents of the response body received from the server.
+    virtual const std::string& response_body() = 0;
+
+    virtual void set_post_data(const std::string& post_data) = 0;
+
+    // Tells the request to begin.
+    virtual void Start() = 0;
+
    protected:
     Request();
   };
 
   // Callback with the result of a call to QueryHistory(). Currently, the
   // DictionaryValue is just the parsed JSON response from the server.
   // TODO(dubroy): Extract the DictionaryValue into a structured results object.
   typedef base::Callback<void(Request*, const base::DictionaryValue*)>
       QueryWebHistoryCallback;
 
   typedef base::Callback<void(bool success)> ExpireWebHistoryCallback;
 
+  typedef base::Callback<void(bool success, bool new_enabled_value)>
+      AudioWebHistoryCallback;
+
+  typedef base::Callback<void(Request*, bool success)> CompletionCallback;
+
   explicit WebHistoryService(Profile* profile);
   ~WebHistoryService() override;
 
+  // This function is pulled out for testing purposes. Caller takes ownership of
+  // the new Request.
+  virtual Request* CreateRequest(const GURL& url,

[sky, 2014/11/19 01:02:41]

Can this and the next be protected?

[rpetterson, 2014/11/19 02:04:56]

Done.

+                                 const CompletionCallback& callback);
+
+  // Extracts a JSON-encoded HTTP response into a DictionaryValue.
+  // If |request|'s HTTP response code indicates failure, or if the response
+  // body is not JSON, a null pointer is returned.
+  static scoped_ptr<base::DictionaryValue> ReadResponse(Request* request);
+
   // Searches synced history for visits matching |text_query|. The timeframe to
   // search, along with other options, is specified in |options|. If
   // |text_query| is empty, all visits in the timeframe will be returned.
   // This method is the equivalent of HistoryService::QueryHistory.
   // The caller takes ownership of the returned Request. If it is destroyed, the
   // request is cancelled.
   scoped_ptr<Request> QueryHistory(
       const base::string16& text_query,
       const QueryOptions& options,
       const QueryWebHistoryCallback& callback);
 
   // Removes all visits to specified URLs in specific time ranges.
   // This is the of equivalent HistoryService::ExpireHistory().
   void ExpireHistory(const std::vector<ExpireHistoryArgs>& expire_list,
                      const ExpireWebHistoryCallback& callback);
 
   // Removes all visits to specified URLs in the given time range.
   // This is the of equivalent HistoryService::ExpireHistoryBetween().
   void ExpireHistoryBetween(const std::set<GURL>& restrict_urls,
                             base::Time begin_time,
                             base::Time end_time,
                             const ExpireWebHistoryCallback& callback);
 
- private:
+  // Requests whether audio history recording is enabled.
+  void GetAudioHistoryEnabled(const AudioWebHistoryCallback& callback);
+
+  // Sets the state of audio history recording to |new_enabled_value|.
+  void SetAudioHistoryEnabled(bool new_enabled_value,
+                              const AudioWebHistoryCallback& callback);
+ protected:
+   friend class WebHistoryServiceTest;
+
   // Called by |request| when a web history query has completed. Unpacks the
   // response and calls |callback|, which is the original callback that was
   // passed to QueryHistory().
   static void QueryHistoryCompletionCallback(
       const WebHistoryService::QueryWebHistoryCallback& callback,
       WebHistoryService::Request* request,
       bool success);
 
   // Called by |request| when a request to delete history from the server has
   // completed. Unpacks the response and calls |callback|, which is the original
   // callback that was passed to ExpireHistory().
   void ExpireHistoryCompletionCallback(
       const WebHistoryService::ExpireWebHistoryCallback& callback,
       WebHistoryService::Request* request,
       bool success);
 
+  // Called by |request| when a request to get or set audio history from the
+  // server has completed. Unpacks the response and calls |callback|, which is
+  // the original callback that was passed to AudioHistory().
+  void AudioHistoryCompletionCallback(
+    const WebHistoryService::AudioWebHistoryCallback& callback,
+    WebHistoryService::Request* request,
+    bool success);
+
   Profile* profile_;

[sky, 2014/11/19 01:02:41]

Style guide says no protected fields.

[rpetterson, 2014/11/19 02:04:56]

Done.

 
   // Stores the version_info token received from the server in response to
   // a mutation operation (e.g., deleting history). This is used to ensure that
   // subsequent reads see a version of the data that includes the mutation.
   std::string server_version_info_;
 
   // Pending expiration requests to be canceled if not complete by profile
   // shutdown.
   std::set<Request*> pending_expire_requests_;
 
+  // Pending requests to be canceled if not complete by profile shutdown.
+  std::set<Request*> pending_audio_history_requests_;
+
   base::WeakPtrFactory<WebHistoryService> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(WebHistoryService);
 };
 
 }  // namespace history
 
 #endif  // CHROME_BROWSER_HISTORY_WEB_HISTORY_SERVICE_H_