Revert of Componentize WebHistoryService

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 "components/history/core/browser/web_history_service.h"
+#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"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
+#include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
+#include "chrome/browser/signin/signin_manager_factory.h"
+#include "components/signin/core/browser/profile_oauth2_token_service.h"
 #include "components/signin/core/browser/signin_manager.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "google_apis/gaia/oauth2_token_service.h"
 #include "net/base/load_flags.h"
 #include "net/base/url_util.h"
 #include "net/http/http_status_code.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
-#include "net/url_request/url_request_context_getter.h"
 #include "url/gurl.h"
 
 namespace history {
 
 namespace {
 
 const char kHistoryOAuthScope[] =
     "https://www.googleapis.com/auth/chromesync";
 
 const char kHistoryQueryHistoryUrl[] =
@@ skipping 24 matching lines @@
   int GetResponseCode() override { return response_code_; }
 
   // Returns the contents of the response body received from the server.
   const std::string& GetResponseBody() override { return response_body_; }
 
   bool IsPending() override { return is_pending_; }
 
  private:
   friend class history::WebHistoryService;
 
-  RequestImpl(
-      OAuth2TokenService* token_service,
-      SigninManagerBase* signin_manager,
-      const scoped_refptr<net::URLRequestContextGetter>& request_context,
-      const GURL& url,
-      const WebHistoryService::CompletionCallback& callback)
+  RequestImpl(Profile* profile,
+              const GURL& url,
+              const WebHistoryService::CompletionCallback& callback)
       : OAuth2TokenService::Consumer("web_history"),
-        token_service_(token_service),
-        signin_manager_(signin_manager),
+        profile_(profile),
         url_(url),
         response_code_(0),
         auth_retry_count_(0),
         callback_(callback),
-        is_pending_(false) {}
+        is_pending_(false) {
+  }
 
   // Tells the request to do its thang.
   void Start() override {
     OAuth2TokenService::ScopeSet oauth_scopes;
     oauth_scopes.insert(kHistoryOAuthScope);
 
-    token_request_ = token_service_->StartRequest(
-        signin_manager_->GetAuthenticatedAccountId(), oauth_scopes, this);
+    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;
   }
 
   // content::URLFetcherDelegate interface.
   void OnURLFetchComplete(const net::URLFetcher* source) override {
     DCHECK_EQ(source, url_fetcher_.get());
     response_code_ = url_fetcher_->GetResponseCode();
 
     UMA_HISTOGRAM_CUSTOM_ENUMERATION("WebHistory.OAuthTokenResponseCode",
         net::HttpUtil::MapStatusCodeForHistogram(response_code_),
         net::HttpUtil::GetStatusCodesForHistogram());
 
     // If the response code indicates that the token might not be valid,
     // invalidate the token and try again.
     if (response_code_ == net::HTTP_UNAUTHORIZED && ++auth_retry_count_ <= 1) {
       OAuth2TokenService::ScopeSet oauth_scopes;
       oauth_scopes.insert(kHistoryOAuthScope);
-      token_service_->InvalidateToken(
-          signin_manager_->GetAuthenticatedAccountId(),
+      ProfileOAuth2TokenService* token_service =
+          ProfileOAuth2TokenServiceFactory::GetForProfile(profile_);
+      SigninManagerBase* signin_manager =
+          SigninManagerFactory::GetForProfile(profile_);
+      token_service->InvalidateToken(
+          signin_manager->GetAuthenticatedAccountId(),
           oauth_scopes,
           access_token_);
 
       access_token_.clear();
       Start();
       return;
     }
     url_fetcher_->GetResponseAsString(&response_body_);
     url_fetcher_.reset();
     is_pending_ = false;
@@ skipping 28 matching lines @@
     // It is valid for the callback to delete |this|, so do not access any
     // members below here.
   }
 
   // Helper for creating a new URLFetcher for the API request.
   net::URLFetcher* CreateUrlFetcher(const std::string& access_token) {
     net::URLFetcher::RequestType request_type = post_data_.empty() ?
         net::URLFetcher::GET : net::URLFetcher::POST;
     net::URLFetcher* fetcher = net::URLFetcher::Create(
         url_, request_type, this);
-    fetcher->SetRequestContext(request_context_.get());
+    fetcher->SetRequestContext(profile_->GetRequestContext());
     fetcher->SetMaxRetriesOn5xx(kMaxRetries);
     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 SetPostData(const std::string& post_data) override {
     post_data_ = post_data;
   }
 
-  OAuth2TokenService* token_service_;
-  SigninManagerBase* signin_manager_;
-  scoped_refptr<net::URLRequestContextGetter> request_context_;
+  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_;
 
   // The OAuth2 access token request.
   scoped_ptr<OAuth2TokenService::Request> token_request_;
 
@@ skipping 85 matching lines @@
 }
 
 }  // namespace
 
 WebHistoryService::Request::Request() {
 }
 
 WebHistoryService::Request::~Request() {
 }
 
-WebHistoryService::WebHistoryService(
-    OAuth2TokenService* token_service,
-    SigninManagerBase* signin_manager,
-    const scoped_refptr<net::URLRequestContextGetter>& request_context)
-    : token_service_(token_service),
-      signin_manager_(signin_manager),
-      request_context_(request_context),
+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(token_service_, signin_manager_, request_context_, url,
-                         callback);
+  return new RequestImpl(profile_, url, callback);
 }
 
 // static
 scoped_ptr<base::DictionaryValue> WebHistoryService::ReadResponse(
   WebHistoryService::Request* request) {
   scoped_ptr<base::DictionaryValue> result;
   if (request->GetResponseCode() == net::HTTP_OK) {
     base::Value* value = base::JSONReader::Read(request->GetResponseBody());
     if (value && value->IsType(base::Value::TYPE_DICTIONARY))
       result.reset(static_cast<base::DictionaryValue*>(value));
@@ skipping 17 matching lines @@
   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();
 
-  for (const auto& expire : expire_list) {
+  for (std::vector<ExpireHistoryArgs>::const_iterator it = expire_list.begin();
+       it != expire_list.end(); ++it) {
     // Convert the times to server timestamps.
-    std::string min_timestamp = ServerTimeString(expire.begin_time);
+    std::string min_timestamp = ServerTimeString(it->begin_time);
     // TODO(dubroy): Use sane time (crbug.com/146090) here when it's available.
-    base::Time end_time = expire.end_time;
+    base::Time end_time = it->end_time;
     if (end_time.is_null() || end_time > now)
       end_time = now;
     std::string max_timestamp = ServerTimeString(end_time);
 
-    for (const auto& url : expire.urls) {
+    for (std::set<GURL>::const_iterator url_iterator = it->urls.begin();
+         url_iterator != it->urls.end(); ++url_iterator) {
       deletions->Append(
-          CreateDeletion(min_timestamp, max_timestamp, url));
+          CreateDeletion(min_timestamp, max_timestamp, *url_iterator));
     }
     // If no URLs were specified, delete everything in the time range.
-    if (expire.urls.empty())
+    if (it->urls.empty())
       deletions->Append(CreateDeletion(min_timestamp, max_timestamp, GURL()));
   }
   delete_request.Set("del", deletions.release());
   std::string post_data;
   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.
@@ skipping 104 matching lines @@
   bool enabled_value = false;
   if (success) {
     response_value = ReadResponse(request_ptr.get());
     if (response_value)
       response_value->GetBoolean("history_recording_enabled", &enabled_value);
   }
   callback.Run(success, enabled_value);
 }
 
 }  // namespace history