[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 {}
@@ skipping 243 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_);
 }
 
 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(
       &WebHistoryService::QueryHistoryCompletionCallback, callback);
 
@@ skipping 59 matching lines @@
     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.
+  RequestImpl::CompletionCallback completion_callback =
+    base::Bind(&WebHistoryService::AudioHistoryCompletionCallback,
+    weak_ptr_factory_.GetWeakPtr(),
+    callback);
+
+  GURL url(kHistoryAudioHistoryUrl);
+  scoped_ptr<RequestImpl> request(
+    new RequestImpl(profile_, 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.
+  RequestImpl::CompletionCallback completion_callback =
+      base::Bind(&WebHistoryService::AudioHistoryCompletionCallback,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 callback);
+
+  GURL url(kHistoryAudioHistoryChangeUrl);
+  scoped_ptr<RequestImpl> request(
+      new RequestImpl(profile_, 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));
   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));
     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(static_cast<RequestImpl*>(request));
+    if (response_value)
+      response_value->GetBoolean("history_recording_enabled", &enabled_value);
+  }
+  callback.Run(success, enabled_value);
+  pending_audio_history_requests_.erase(request);

[sky, 2014/11/11 20:30:10]

Does this leak request?

[rpetterson, 2014/11/11 22:29:16]

No, it should not. We use the pending_audio_history_requests set to track each
request. Each request is added to the pending_audio_history_requests set when
it's sent. When the callback returns, we delete it from that set. In the
destructor, we delete any pending requests that are still in the set. This is
based on the way expiry requests are handled.

[sky, 2014/11/12 00:46:32]

Where is the delete? From what I see you erase the request right here, which
removes from pending_audio_history_requests_ but doesn't actually delete it.

[rpetterson, 2014/11/12 00:58:42]

Whoops. It's back.

+}
+
 }  // namespace history