Extracted PrivetV1HTTPClient with Privet v1 specific operations.

chrome/browser/local_discovery/privet_http_impl.cc

 // Copyright 2013 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/local_discovery/privet_http_impl.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 69 matching lines @@
   replacements.SetPathStr(path);
   if (!query_params.empty()) {
     replacements.SetQueryStr(query_params);
   }
   return url.ReplaceComponents(replacements);
 }
 
 }  // namespace
 
 PrivetInfoOperationImpl::PrivetInfoOperationImpl(
-    PrivetHTTPClientImpl* privet_client,
+    PrivetHTTPClient* privet_client,
     const PrivetJSONOperation::ResultCallback& callback)
     : privet_client_(privet_client), callback_(callback) {
 }
 
 PrivetInfoOperationImpl::~PrivetInfoOperationImpl() {
 }
 
 void PrivetInfoOperationImpl::Start() {
   url_fetcher_ = privet_client_->CreateURLFetcher(
       CreatePrivetURL(kPrivetInfoPath), net::URLFetcher::GET, this);
@@ skipping 13 matching lines @@
   callback_.Run(NULL);
 }
 
 void PrivetInfoOperationImpl::OnParsedJson(PrivetURLFetcher* fetcher,
                                            const base::DictionaryValue* value,
                                            bool has_error) {
   callback_.Run(value);
 }
 
 PrivetRegisterOperationImpl::PrivetRegisterOperationImpl(
-    PrivetHTTPClientImpl* privet_client,
+    PrivetHTTPClient* privet_client,
     const std::string& user,
     PrivetRegisterOperation::Delegate* delegate)
-    : user_(user), delegate_(delegate), privet_client_(privet_client),
+    : user_(user),
+      delegate_(delegate),
+      privet_client_(privet_client),
       ongoing_(false) {
 }
 
 PrivetRegisterOperationImpl::~PrivetRegisterOperationImpl() {
 }
 
 void PrivetRegisterOperationImpl::Start() {
   ongoing_ = true;
   next_response_handler_ =
       base::Bind(&PrivetRegisterOperationImpl::StartResponse,
@@ skipping 169 matching lines @@
 }
 
 void PrivetRegisterOperationImpl::StartInfoOperation() {
   info_operation_ = privet_client_->CreateInfoOperation(
       base::Bind(&PrivetRegisterOperationImpl::OnPrivetInfoDone,
                  base::Unretained(this)));
   info_operation_->Start();
 }
 
 PrivetRegisterOperationImpl::Cancelation::Cancelation(
-    PrivetHTTPClientImpl* privet_client,
+    PrivetHTTPClient* privet_client,
     const std::string& user) {
   url_fetcher_ =
       privet_client->CreateURLFetcher(
           CreatePrivetRegisterURL(kPrivetActionCancel, user),
           net::URLFetcher::POST, this);
   url_fetcher_->DoNotRetryOnTransientError();
   url_fetcher_->Start();
 }
 
 PrivetRegisterOperationImpl::Cancelation::~Cancelation() {
@@ skipping 10 matching lines @@
     bool has_error) {
 }
 
 void PrivetRegisterOperationImpl::Cancelation::Cleanup() {
   // Nothing needs to be done, as base::Owned will delete this object,
   // this callback is just here to pass ownership of the Cancelation to
   // the message loop.
 }
 
 PrivetJSONOperationImpl::PrivetJSONOperationImpl(
-    PrivetHTTPClientImpl* privet_client,
+    PrivetHTTPClient* privet_client,
     const std::string& path,
     const std::string& query_params,
     const PrivetJSONOperation::ResultCallback& callback)
-    : privet_client_(privet_client), path_(path), query_params_(query_params),
+    : privet_client_(privet_client),
+      path_(path),
+      query_params_(query_params),
       callback_(callback) {
 }
 
 PrivetJSONOperationImpl::~PrivetJSONOperationImpl() {
 }
 
 void PrivetJSONOperationImpl::Start() {
   url_fetcher_ = privet_client_->CreateURLFetcher(
       CreatePrivetParamURL(path_, query_params_), net::URLFetcher::GET, this);
   url_fetcher_->DoNotRetryOnTransientError();
@@ skipping 17 matching lines @@
   callback_.Run(value);
 }
 
 void PrivetJSONOperationImpl::OnNeedPrivetToken(
     PrivetURLFetcher* fetcher,
     const PrivetURLFetcher::TokenCallback& callback) {
   privet_client_->RefreshPrivetToken(callback);
 }
 
 PrivetDataReadOperationImpl::PrivetDataReadOperationImpl(
-    PrivetHTTPClientImpl* privet_client,
+    PrivetHTTPClient* privet_client,
     const std::string& path,
     const std::string& query_params,
     const PrivetDataReadOperation::ResultCallback& callback)
-    : privet_client_(privet_client), path_(path), query_params_(query_params),
-      callback_(callback), has_range_(false), save_to_file_(false) {
+    : privet_client_(privet_client),
+      path_(path),
+      query_params_(query_params),
+      callback_(callback),
+      has_range_(false),
+      save_to_file_(false) {
 }
 
 PrivetDataReadOperationImpl::~PrivetDataReadOperationImpl() {
 }
 
 
 void PrivetDataReadOperationImpl::Start() {
   url_fetcher_ = privet_client_->CreateURLFetcher(
       CreatePrivetParamURL(path_, query_params_), net::URLFetcher::GET, this);
   url_fetcher_->DoNotRetryOnTransientError();
@@ skipping 45 matching lines @@
 bool PrivetDataReadOperationImpl::OnRawData(PrivetURLFetcher* fetcher,
                                             bool is_file,
                                             const std::string& data_str,
                                             const base::FilePath& file_path) {
   ResponseType type = (is_file) ? RESPONSE_TYPE_FILE : RESPONSE_TYPE_STRING;
   callback_.Run(type, data_str, file_path);
   return true;
 }
 
 PrivetLocalPrintOperationImpl::PrivetLocalPrintOperationImpl(
-    PrivetHTTPClientImpl* privet_client,
+    PrivetHTTPClient* privet_client,
     PrivetLocalPrintOperation::Delegate* delegate)
     : privet_client_(privet_client),
       delegate_(delegate),
       use_pdf_(false),
       has_extended_workflow_(false),
       started_(false),
       offline_(false),
       dpi_(printing::kDefaultPdfDpi),
       invalid_job_retries_(0),
       weak_factory_(this) {
@@ skipping 346 matching lines @@
 
 PrivetHTTPClientImpl::PrivetHTTPClientImpl(
     const std::string& name,
     const net::HostPortPair& host_port,
     net::URLRequestContextGetter* request_context)
     : name_(name), request_context_(request_context), host_port_(host_port) {}
 
 PrivetHTTPClientImpl::~PrivetHTTPClientImpl() {
 }
 
-scoped_ptr<PrivetRegisterOperation>
-PrivetHTTPClientImpl::CreateRegisterOperation(
-    const std::string& user,
-    PrivetRegisterOperation::Delegate* delegate) {
-  return scoped_ptr<PrivetRegisterOperation>(
-      new PrivetRegisterOperationImpl(this, user, delegate));
+const std::string& PrivetHTTPClientImpl::GetName() {
+  return name_;
 }
 
 scoped_ptr<PrivetJSONOperation> PrivetHTTPClientImpl::CreateInfoOperation(
     const PrivetJSONOperation::ResultCallback& callback) {
   return scoped_ptr<PrivetJSONOperation>(
       new PrivetInfoOperationImpl(this, callback));
 }
 
-scoped_ptr<PrivetJSONOperation>
-PrivetHTTPClientImpl::CreateCapabilitiesOperation(
-    const PrivetJSONOperation::ResultCallback& callback) {
-  return scoped_ptr<PrivetJSONOperation>(
-      new PrivetJSONOperationImpl(this, kPrivetCapabilitiesPath, "", callback));
-}
-
-scoped_ptr<PrivetLocalPrintOperation>
-PrivetHTTPClientImpl::CreateLocalPrintOperation(
-    PrivetLocalPrintOperation::Delegate* delegate) {
-  return scoped_ptr<PrivetLocalPrintOperation>(
-      new PrivetLocalPrintOperationImpl(this, delegate));
-}
-
-scoped_ptr<PrivetJSONOperation>
-PrivetHTTPClientImpl::CreateStorageListOperation(
-      const std::string& path,
-      const PrivetJSONOperation::ResultCallback& callback) {
-  std::string url_param = base::StringPrintf(kPrivetStorageParamPathFormat,
-                                            path.c_str());
-  return scoped_ptr<PrivetJSONOperation>(
-      new PrivetJSONOperationImpl(this, kPrivetStorageListPath, url_param,
-                                  callback));
-}
-
-
-scoped_ptr<PrivetDataReadOperation>
-PrivetHTTPClientImpl::CreateStorageReadOperation(
-    const std::string& path,
-    const PrivetDataReadOperation::ResultCallback& callback) {
-  std::string url_param = base::StringPrintf(kPrivetStorageParamPathFormat,
-                                             path.c_str());
-  return scoped_ptr<PrivetDataReadOperation>(
-      new PrivetDataReadOperationImpl(this, kPrivetStorageContentPath,
-                                      url_param, callback));
-}
-
-const std::string& PrivetHTTPClientImpl::GetName() {
-  return name_;
-}
-
 scoped_ptr<PrivetURLFetcher> PrivetHTTPClientImpl::CreateURLFetcher(
-    const GURL& url, net::URLFetcher::RequestType request_type,
-    PrivetURLFetcher::Delegate* delegate) const {
+    const GURL& url,
+    net::URLFetcher::RequestType request_type,
+    PrivetURLFetcher::Delegate* delegate) {
   GURL::Replacements replacements;
   replacements.SetHostStr(host_port_.host());
   std::string port(base::IntToString(host_port_.port()));  // Keep string alive.
   replacements.SetPortStr(port);
   return scoped_ptr<PrivetURLFetcher>(
       new PrivetURLFetcher(url.ReplaceComponents(replacements),
                            request_type,
                            request_context_.get(),
                            delegate));
 }
@@ skipping 23 matching lines @@
 
   TokenCallbackVector token_callbacks;
   token_callbacks_.swap(token_callbacks);
 
   for (TokenCallbackVector::iterator i = token_callbacks.begin();
        i != token_callbacks.end(); i++) {
     i->Run(token);
   }
 }
 
+PrivetV1HTTPClientImpl::PrivetV1HTTPClientImpl(
+    scoped_ptr<PrivetHTTPClient> info_client)
+    : info_client_(info_client.Pass()) {
+}
+
+PrivetV1HTTPClientImpl::~PrivetV1HTTPClientImpl() {
+}
+
+const std::string& PrivetV1HTTPClientImpl::GetName() {
+  return info_client()->GetName();
+}
+
+scoped_ptr<PrivetJSONOperation> PrivetV1HTTPClientImpl::CreateInfoOperation(
+    const PrivetJSONOperation::ResultCallback& callback) {
+  return info_client()->CreateInfoOperation(callback);
+}
+
+scoped_ptr<PrivetRegisterOperation>
+PrivetV1HTTPClientImpl::CreateRegisterOperation(
+    const std::string& user,
+    PrivetRegisterOperation::Delegate* delegate) {
+  return scoped_ptr<PrivetRegisterOperation>(
+      new PrivetRegisterOperationImpl(info_client(), user, delegate));
+}
+
+scoped_ptr<PrivetJSONOperation>
+PrivetV1HTTPClientImpl::CreateCapabilitiesOperation(
+    const PrivetJSONOperation::ResultCallback& callback) {
+  return scoped_ptr<PrivetJSONOperation>(new PrivetJSONOperationImpl(
+      info_client(), kPrivetCapabilitiesPath, "", callback));
+}
+
+scoped_ptr<PrivetLocalPrintOperation>
+PrivetV1HTTPClientImpl::CreateLocalPrintOperation(
+    PrivetLocalPrintOperation::Delegate* delegate) {
+  return scoped_ptr<PrivetLocalPrintOperation>(
+      new PrivetLocalPrintOperationImpl(info_client(), delegate));
+}
+
+scoped_ptr<PrivetJSONOperation>
+PrivetV1HTTPClientImpl::CreateStorageListOperation(
+    const std::string& path,
+    const PrivetJSONOperation::ResultCallback& callback) {
+  std::string url_param =
+      base::StringPrintf(kPrivetStorageParamPathFormat, path.c_str());
+  return scoped_ptr<PrivetJSONOperation>(new PrivetJSONOperationImpl(
+      info_client(), kPrivetStorageListPath, url_param, callback));
+}
+
+scoped_ptr<PrivetDataReadOperation>
+PrivetV1HTTPClientImpl::CreateStorageReadOperation(
+    const std::string& path,
+    const PrivetDataReadOperation::ResultCallback& callback) {
+  std::string url_param =
+      base::StringPrintf(kPrivetStorageParamPathFormat, path.c_str());
+  return scoped_ptr<PrivetDataReadOperation>(new PrivetDataReadOperationImpl(
+      info_client(), kPrivetStorageContentPath, url_param, callback));
+}
+
 }  // namespace local_discovery