[Hotword] Implement audio history pref accessing and setting.

chrome/browser/history/web_history_service.cc

 // 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.
 
 #include "chrome/browser/history/web_history_service.h"
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/metrics/histogram.h"
@@ skipping 22 matching lines @@
 
 const char kHistoryOAuthScope[] =
     "https://www.googleapis.com/auth/chromesync";
 
 const char kHistoryQueryHistoryUrl[] =
     "https://history.google.com/history/api/lookup?client=chrome";
 
 const char kHistoryDeleteHistoryUrl[] =
     "https://history.google.com/history/api/delete?client=chrome";
 
+const char kHistoryAudioHistoryUrl[] =
+    "https://history.google.com/history/api/lookup?client=audio";
+
+const char kHistoryAudioHistoryChangeUrl[] =
+    "https://history.google.com/history/api/change";
+
 const char kPostDataMimeType[] = "text/plain";
 
 // The maximum number of retries for the URLFetcher requests.
 const size_t kMaxRetries = 1;
 
 class RequestImpl : public WebHistoryService::Request,
                     private OAuth2TokenService::Consumer,
                     private net::URLFetcherDelegate {
  public:
   ~RequestImpl() override {}
 
   // Returns the response code received from the server, which will only be
   // valid if the request succeeded.
-  int response_code() { return response_code_; }
+  int response_code() override { return response_code_; }
 
   // Returns the contents of the response body received from the server.
-  const std::string& response_body() { return response_body_; }
+  const std::string& response_body() override { return response_body_; }
 
   bool is_pending() override { return is_pending_; }
 
  private:
   friend class history::WebHistoryService;
 
-  typedef base::Callback<void(Request*, bool)> CompletionCallback;
-
   RequestImpl(Profile* profile,
               const GURL& url,
-              const CompletionCallback& callback)
+              const WebHistoryService::CompletionCallback& callback)
       : OAuth2TokenService::Consumer("web_history"),
         profile_(profile),
         url_(url),
         response_code_(0),
         auth_retry_count_(0),
         callback_(callback),
         is_pending_(false) {
   }
 
   // Tells the request to do its thang.
-  void Start() {
+  void Start() override {
     OAuth2TokenService::ScopeSet oauth_scopes;
     oauth_scopes.insert(kHistoryOAuthScope);
 
     ProfileOAuth2TokenService* token_service =
         ProfileOAuth2TokenServiceFactory::GetForProfile(profile_);
     SigninManagerBase* signin_manager =
         SigninManagerFactory::GetForProfile(profile_);
     token_request_ = token_service->StartRequest(
         signin_manager->GetAuthenticatedAccountId(), oauth_scopes, this);
     is_pending_ = true;
@@ skipping 72 matching lines @@
     fetcher->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
                           net::LOAD_DO_NOT_SAVE_COOKIES);
     fetcher->AddExtraRequestHeader("Authorization: Bearer " + access_token);
     fetcher->AddExtraRequestHeader("X-Developer-Key: " +
         GaiaUrls::GetInstance()->oauth2_chrome_client_id());
     if (request_type == net::URLFetcher::POST)
       fetcher->SetUploadData(kPostDataMimeType, post_data_);
     return fetcher;
   }
 
-  void set_post_data(const std::string& post_data) {
+  void set_post_data(const std::string& post_data) override {
     post_data_ = post_data;
   }
 
   Profile* profile_;
 
   // The URL of the API endpoint.
   GURL url_;
 
   // POST data to be sent with the request (may be empty).
   std::string post_data_;
@@ skipping 11 matching lines @@
   int response_code_;
 
   // Holds the response body received from the server.
   std::string response_body_;
 
   // The number of times this request has already been retried due to
   // authorization problems.
   int auth_retry_count_;
 
   // The callback to execute when the query is complete.
-  CompletionCallback callback_;
+  WebHistoryService::CompletionCallback callback_;
 
   // True if the request was started and has not yet completed, otherwise false.
   bool is_pending_;
 };
 
-// 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.
-scoped_ptr<base::DictionaryValue> ReadResponse(RequestImpl* request) {
-  scoped_ptr<base::DictionaryValue> result;
-  if (request->response_code() == net::HTTP_OK) {
-    base::Value* value = base::JSONReader::Read(request->response_body());
-    if (value && value->IsType(base::Value::TYPE_DICTIONARY))
-      result.reset(static_cast<base::DictionaryValue*>(value));
-    else
-      DLOG(WARNING) << "Non-JSON response received from history server.";
-  }
-  return result.Pass();
-}
-
 // Converts a time into a string for use as a parameter in a request to the
 // history server.
 std::string ServerTimeString(base::Time time) {
   if (time < base::Time::UnixEpoch()) {
     return base::Int64ToString(0);
   } else {
     return base::Int64ToString(
         (time - base::Time::UnixEpoch()).InMicroseconds());
   }
 }
@@ skipping 59 matching lines @@
 WebHistoryService::Request::~Request() {
 }
 
 WebHistoryService::WebHistoryService(Profile* profile)
     : profile_(profile),
       weak_ptr_factory_(this) {
 }
 
 WebHistoryService::~WebHistoryService() {
   STLDeleteElements(&pending_expire_requests_);
+  STLDeleteElements(&pending_audio_history_requests_);
+}
+
+WebHistoryService::Request* WebHistoryService::CreateRequest(
+    const GURL& url,
+    const CompletionCallback& callback) {
+  return new RequestImpl(profile_, url, callback);
+}
+
+// static
+scoped_ptr<base::DictionaryValue> WebHistoryService::ReadResponse(
+  WebHistoryService::Request* request) {
+  scoped_ptr<base::DictionaryValue> result;
+  if (request->response_code() == net::HTTP_OK) {
+    base::Value* value = base::JSONReader::Read(request->response_body());
+    if (value && value->IsType(base::Value::TYPE_DICTIONARY))
+      result.reset(static_cast<base::DictionaryValue*>(value));
+    else
+      DLOG(WARNING) << "Non-JSON response received from history server.";
+  }
+  return result.Pass();
 }
 
 scoped_ptr<WebHistoryService::Request> WebHistoryService::QueryHistory(
     const base::string16& text_query,
     const QueryOptions& options,
     const WebHistoryService::QueryWebHistoryCallback& callback) {
   // Wrap the original callback into a generic completion callback.
-  RequestImpl::CompletionCallback completion_callback = base::Bind(
+  CompletionCallback completion_callback = base::Bind(
       &WebHistoryService::QueryHistoryCompletionCallback, callback);
 
   GURL url = GetQueryUrl(text_query, options, server_version_info_);
-  scoped_ptr<RequestImpl> request(
-      new RequestImpl(profile_, url, completion_callback));
+  scoped_ptr<Request> request(CreateRequest(url, completion_callback));
   request->Start();
   return request.Pass();
 }
 
 void WebHistoryService::ExpireHistory(
     const std::vector<ExpireHistoryArgs>& expire_list,
     const ExpireWebHistoryCallback& callback) {
   base::DictionaryValue delete_request;
   scoped_ptr<base::ListValue> deletions(new base::ListValue);
   base::Time now = base::Time::Now();
@@ skipping 22 matching lines @@
   base::JSONWriter::Write(&delete_request, &post_data);
 
   GURL url(kHistoryDeleteHistoryUrl);
 
   // Append the version info token, if it is available, to help ensure
   // consistency with any previous deletions.
   if (!server_version_info_.empty())
     url = net::AppendQueryParameter(url, "kvi", server_version_info_);
 
   // Wrap the original callback into a generic completion callback.
-  RequestImpl::CompletionCallback completion_callback =
+  CompletionCallback completion_callback =
       base::Bind(&WebHistoryService::ExpireHistoryCompletionCallback,
                  weak_ptr_factory_.GetWeakPtr(),
                  callback);
 
-  scoped_ptr<RequestImpl> request(
-      new RequestImpl(profile_, url, completion_callback));
+  scoped_ptr<Request> request(CreateRequest(url, completion_callback));
   request->set_post_data(post_data);
   request->Start();
   pending_expire_requests_.insert(request.release());
 }
 
 void WebHistoryService::ExpireHistoryBetween(
     const std::set<GURL>& restrict_urls,
     base::Time begin_time,
     base::Time end_time,
     const ExpireWebHistoryCallback& callback) {
   std::vector<ExpireHistoryArgs> expire_list(1);
   expire_list.back().urls = restrict_urls;
   expire_list.back().begin_time = begin_time;
   expire_list.back().end_time = end_time;
   ExpireHistory(expire_list, callback);
 }
 
+void WebHistoryService::GetAudioHistoryEnabled(
+    const AudioWebHistoryCallback& callback) {
+  // Wrap the original callback into a generic completion callback.
+  CompletionCallback completion_callback =
+    base::Bind(&WebHistoryService::AudioHistoryCompletionCallback,
+    weak_ptr_factory_.GetWeakPtr(),
+    callback);
+
+  GURL url(kHistoryAudioHistoryUrl);
+  scoped_ptr<Request> request(CreateRequest(url, completion_callback));
+  request->Start();
+  pending_audio_history_requests_.insert(request.release());
+}
+
+void WebHistoryService::SetAudioHistoryEnabled(
+  bool new_enabled_value,
+  const AudioWebHistoryCallback& callback) {
+  // Wrap the original callback into a generic completion callback.
+  CompletionCallback completion_callback =
+      base::Bind(&WebHistoryService::AudioHistoryCompletionCallback,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 callback);
+
+  GURL url(kHistoryAudioHistoryChangeUrl);
+  scoped_ptr<Request> request(CreateRequest(url, completion_callback));
+
+  base::DictionaryValue enable_audio_history;
+  enable_audio_history.SetBoolean("enable_history_recording",
+                                  new_enabled_value);
+  enable_audio_history.SetString("client", "audio");
+  std::string post_data;
+  base::JSONWriter::Write(&enable_audio_history, &post_data);
+  request->set_post_data(post_data);
+
+  request->Start();
+  pending_audio_history_requests_.insert(request.release());
+}
+
 // static
 void WebHistoryService::QueryHistoryCompletionCallback(
     const WebHistoryService::QueryWebHistoryCallback& callback,
     WebHistoryService::Request* request,
     bool success) {
   scoped_ptr<base::DictionaryValue> response_value;
   if (success)
-    response_value = ReadResponse(static_cast<RequestImpl*>(request));
+    response_value = ReadResponse(request);
   callback.Run(request, response_value.get());
 }
 
 void WebHistoryService::ExpireHistoryCompletionCallback(
     const WebHistoryService::ExpireWebHistoryCallback& callback,
     WebHistoryService::Request* request,
     bool success) {
   scoped_ptr<base::DictionaryValue> response_value;
   if (success) {
-    response_value = ReadResponse(static_cast<RequestImpl*>(request));
+    response_value = ReadResponse(request);
     if (response_value)
       response_value->GetString("version_info", &server_version_info_);
   }
   callback.Run(response_value.get() && success);
   // Clean up from pending requests.
   pending_expire_requests_.erase(request);
   delete request;
 }
 
+void WebHistoryService::AudioHistoryCompletionCallback(
+    const WebHistoryService::AudioWebHistoryCallback& callback,
+    WebHistoryService::Request* request,
+    bool success) {
+  scoped_ptr<base::DictionaryValue> response_value;
+  bool enabled_value = false;
+  if (success) {
+    response_value = ReadResponse(request);
+    if (response_value)
+      response_value->GetBoolean("history_recording_enabled", &enabled_value);
+  }
+  callback.Run(success, enabled_value);
+  pending_audio_history_requests_.erase(request);
+  delete request;
+}
+
 }  // namespace history