GCP2.0 Device: Receiving printjobs.

cloud_print/gcp20/prototype/cloud_print_requester.cc

Index: cloud_print/gcp20/prototype/cloud_print_requester.cc
diff --git a/cloud_print/gcp20/prototype/cloud_print_requester.cc b/cloud_print/gcp20/prototype/cloud_print_requester.cc
index d5c2494867e0c621ef07f8dbea6f1a9b4a6ceeaa..c48dbbee6468c3fcd565fb40551794e069716128 100644
--- a/cloud_print/gcp20/prototype/cloud_print_requester.cc
+++ b/cloud_print/gcp20/prototype/cloud_print_requester.cc
@@ -4,22 +4,25 @@
 
 #include "cloud_print/gcp20/prototype/cloud_print_requester.h"
 
+#include "base/bind.h"
 #include "base/md5.h"
 #include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
 #include "base/strings/stringprintf.h"
-#include "cloud_print/gcp20/prototype/cloud_print_response_parser.h"
 #include "google_apis/google_api_keys.h"
-#include "net/base/load_flags.h"
 #include "net/base/mime_util.h"
 #include "net/base/url_util.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_builder.h"
+#include "net/url_request/url_request_context_getter.h"
 #include "url/gurl.h"
 
 const char kCloudPrintUrl[] = "https://www.google.com/cloudprint";
 
+// TODO(maksymb): Replace constant with command line switch.
+const bool kFunctionVebose = true;
+
 namespace {
 
 const char kProxyIdValue[] = "proxy";
@@ -34,6 +37,19 @@ GURL CreateRegisterUrl() {
   return GURL(std::string(kCloudPrintUrl) + "/register");
 }
 
+GURL CreateFetchUrl(const std::string& device_id) {
+  GURL url(std::string(kCloudPrintUrl) + "/fetch");
+  url = net::AppendQueryParameter(url, "printerid", device_id);
+  return url;
+}
+
+GURL CreateControlUrl(const std::string& jobid, const std::string& status) {
+  GURL url(std::string(kCloudPrintUrl) + "/control");
+  url = net::AppendQueryParameter(url, "jobid", jobid);
+  url = net::AppendQueryParameter(url, "status", status);
+  return url;
+}
+
 }  // namespace
 
 // Used to return a dummy context, which lives on the message loop
@@ -89,7 +105,11 @@ CloudPrintRequester::CloudPrintRequester(
 CloudPrintRequester::~CloudPrintRequester() {
 }
 
-bool CloudPrintRequester::StartRegistration(const std::string& proxy_id,
+bool CloudPrintRequester::IsBusy() const {
+  return request_ || gaia_;
+}
+
+void CloudPrintRequester::StartRegistration(const std::string& proxy_id,
                                             const std::string& device_name,
                                             const std::string& user,
                                             const std::string& cdd) {
@@ -99,66 +119,115 @@ bool CloudPrintRequester::StartRegistration(const std::string& proxy_id,
   base::SStringPrintf(&mime_boundary,
                       "---------------------------%08X%08X", r1, r2);
 
-  std::string data;
-  net::AddMultipartValueForUpload(kProxyIdValue, proxy_id,
-                                  mime_boundary, std::string(), &data);
-  net::AddMultipartValueForUpload(kPrinterNameValue, device_name,
-                                  mime_boundary, std::string(), &data);
-  net::AddMultipartValueForUpload("use_cdd", "true",
-                                  mime_boundary, std::string(), &data);
-  net::AddMultipartValueForUpload(kPrinterNameValue, device_name,
-                                  mime_boundary, std::string(), &data);
-  net::AddMultipartValueForUpload(kPrinterCapsValue, cdd,
-                                  mime_boundary, "application/json", &data);
+  CloudPrintRequest::DataForUpload data;
+  data.content_type = "multipart/form-data; boundary=" + mime_boundary;
+
+  net::AddMultipartValueForUpload(kProxyIdValue, proxy_id, mime_boundary,
+                                  std::string(), &data.content);
+  net::AddMultipartValueForUpload(kPrinterNameValue, device_name, mime_boundary,
+                                  std::string(), &data.content);
+  net::AddMultipartValueForUpload("use_cdd", "true", mime_boundary,
+                                  std::string(), &data.content);
+  net::AddMultipartValueForUpload(kPrinterNameValue, device_name, mime_boundary,
+                                  std::string(), &data.content);
+  net::AddMultipartValueForUpload(kPrinterCapsValue, cdd, mime_boundary,
+                                  "application/json", &data.content);
   net::AddMultipartValueForUpload(kPrinterCapsHashValue, base::MD5String(cdd),
-                                  mime_boundary, std::string(), &data);
+                                  mime_boundary, std::string(), &data.content);
   net::AddMultipartValueForUpload(kPrinterUserValue, user,
-                                  mime_boundary, std::string(), &data);
-  net::AddMultipartFinalDelimiterForUpload(mime_boundary, &data);
+                                  mime_boundary, std::string(), &data.content);
+  net::AddMultipartFinalDelimiterForUpload(mime_boundary, &data.content);
 
-  std::string mime_type("multipart/form-data; boundary=" + mime_boundary);
+  request_ = CreatePost(CreateRegisterUrl(), data);
+  request_->Run(base::Bind(&CloudPrintRequester::ParseRegisterStart,
+                           base::Unretained(this)));
+}
+
+void CloudPrintRequester::CompleteRegistration() {
+  request_ = CreateGet(GURL(polling_url_ + oauth_client_info_.client_id));
+  request_->Run(base::Bind(&CloudPrintRequester::ParseRegisterComplete,
+                           base::Unretained(this)));
+}
 
-  if (!CreateRequest(
-      CreateRegisterUrl(), net::URLFetcher::POST,
-      base::Bind(&CloudPrintRequester::ParseRegisterStartResponse,
-                 base::Unretained(this)))) {
-    return false;
+void CloudPrintRequester::FetchPrintjobs(const std::string& refresh_token,
+                                         const std::string& device_id) {
+  LOG_IF(INFO, kFunctionVebose) << "Function: " << __FUNCTION__;
+  if (IsBusy())
+    return;
+
+  if (access_token_.empty()) {
+    UpdateAccesstoken(refresh_token);
+    return;
   }
-  fetcher_->SetUploadData(mime_type, data);
-  fetcher_->Start();
 
-  return true;
+  LOG_IF(INFO, kFunctionVebose) << "Function: " << __FUNCTION__ <<
+      ": request created";
+  request_ = CreateGet(CreateFetchUrl(device_id));
+  request_->Run(base::Bind(&CloudPrintRequester::ParseFetch,
+                           base::Unretained(this)));
 }
 
-bool CloudPrintRequester::CompleteRegistration() {
-  if (!CreateRequest(
-      GURL(polling_url_ + oauth_client_info_.client_id),
-      net::URLFetcher::GET,
-      base::Bind(&CloudPrintRequester::ParseRegisterCompleteResponse,
-                 base::Unretained(this)))) {
-    return false;
-  }
-  fetcher_->Start();
+void CloudPrintRequester::UpdateAccesstoken(const std::string& refresh_token) {
+  LOG_IF(INFO, kFunctionVebose) << "Function: " << __FUNCTION__;
+  DCHECK(!IsBusy());
+  gaia_.reset(new gaia::GaiaOAuthClient(context_getter_.get()));
+  gaia_->RefreshToken(oauth_client_info_, refresh_token,
+                      std::vector<std::string>(), kGaiaMaxRetries, this);
+  delegate_->OnServerError("Access token requested.");
+}
+
+void CloudPrintRequester::RequestPrintjob(const Printjob& printjob) {
+  LOG_IF(INFO, kFunctionVebose) << "Function: " << __FUNCTION__;
+  current_printjob_.reset(new Printjob(printjob));
+  request_ = CreateGet(CreateControlUrl(current_printjob_->jobid,
+                                        "IN_PROGRESS"));
+  request_->Run(
+      base::Bind(&CloudPrintRequester::ParsePrintjobInProgress,
+                 base::Unretained(this)));
 
-  return true;
 }
 
-void CloudPrintRequester::OnURLFetchComplete(const net::URLFetcher* source) {
-  std::string response;
-  source->GetResponseAsString(&response);
-  fetcher_.reset();
-  VLOG(1) << response;
+void CloudPrintRequester::SendPrintjobDone(const std::string& jobid) {
+  LOG_IF(INFO, kFunctionVebose) << "Function: " << __FUNCTION__;
+  request_ = CreateGet(CreateControlUrl(jobid, "DONE"));
+  request_->Run(base::Bind(&CloudPrintRequester::ParsePrintjobDone,
+                           base::Unretained(this)));
+}
 
-  // TODO(maksymb): Add |server_http_code| and |server_api| info for errors.
-  if (!parse_response_callback_.is_null()) {
-    parse_response_callback_.Run(response);
-    parse_response_callback_.Reset();
-  }
+void CloudPrintRequester::OnFetchComplete() {
+  LOG_IF(INFO, kFunctionVebose) << "Function: " << __FUNCTION__;
+  request_.reset();
+}
+
+void CloudPrintRequester::OnFetchError(const std::string& server_api,
+                                       int server_code, int server_http_code) {
+  LOG_IF(INFO, kFunctionVebose) << "Function: " << __FUNCTION__;
+  request_.reset();
+  delegate_->OnServerError("Fetch error");
+  NOTIMPLEMENTED();
+}
+
+void CloudPrintRequester::OnFetchTimeoutReached() {
+  LOG_IF(INFO, kFunctionVebose) << "Function: " << __FUNCTION__;
+  request_.reset();
+  current_printjob_.reset();
+  delegate_->OnNetworkError();
+}
+
+std::string CloudPrintRequester::access_token() {
+  return access_token_;
+}
+
+scoped_refptr<net::URLRequestContextGetter>
+    CloudPrintRequester::context_getter() {
+  return context_getter_;
 }
 
 void CloudPrintRequester::OnGetTokensResponse(const std::string& refresh_token,
                                               const std::string& access_token,
                                               int expires_in_seconds) {
+  LOG_IF(INFO, kFunctionVebose) << "Function: " << __FUNCTION__;
+  gaia_.reset();
   access_token_ = access_token;
   delegate_->OnGetAuthCodeResponseParsed(refresh_token);
 }
@@ -166,42 +235,37 @@ void CloudPrintRequester::OnGetTokensResponse(const std::string& refresh_token,
 void CloudPrintRequester::OnRefreshTokenResponse(
     const std::string& access_token,
     int expires_in_seconds) {
-  NOTIMPLEMENTED();
+  LOG_IF(INFO, kFunctionVebose) << "Function: " << __FUNCTION__;
+  gaia_.reset();
+  access_token_ = access_token;
+  LOG(INFO) << "New accesstoken: " << access_token;
 }
 
 void CloudPrintRequester::OnOAuthError() {
+  LOG_IF(INFO, kFunctionVebose) << "Function: " << __FUNCTION__;
+  gaia_.reset();
   NOTIMPLEMENTED();
 }
 
 void CloudPrintRequester::OnNetworkError(int response_code) {
+  LOG_IF(INFO, kFunctionVebose) << "Function: " << __FUNCTION__;
+  gaia_.reset();
   NOTIMPLEMENTED();
 }
 
-bool CloudPrintRequester::CreateRequest(const GURL& url,
-                                        net::URLFetcher::RequestType method,
-                                        const ParserCallback& callback) {
-  if (fetcher_)
-    return false;  // Only one query is supported.
-
-  fetcher_.reset(net::URLFetcher::Create(url, method, this));
-  fetcher_->SetRequestContext(context_getter_);
-
-  int load_flags = fetcher_->GetLoadFlags();
-  load_flags |= net::LOAD_DO_NOT_SEND_COOKIES;
-  load_flags |= net::LOAD_DO_NOT_SAVE_COOKIES;
-  fetcher_->SetLoadFlags(load_flags);
-
-  fetcher_->AddExtraRequestHeader("X-CloudPrint-Proxy: \"\"");
-  if (!access_token_.empty())
-    fetcher_->AddExtraRequestHeader("Authorization: Bearer " + access_token_);
-
-  parse_response_callback_ = callback;
+scoped_ptr<CloudPrintRequest> CloudPrintRequester::CreateGet(const GURL& url) {
+  DCHECK(!IsBusy());
+  return CloudPrintRequest::CreateGet(url, this);
+}
 
-  return true;
+scoped_ptr<CloudPrintRequest> CloudPrintRequester::CreatePost(
+    const GURL& url,
+    const CloudPrintRequest::DataForUpload& data) {
+  DCHECK(!IsBusy());
+  return CloudPrintRequest::CreatePost(url, data, this);
 }
 
-void CloudPrintRequester::ParseRegisterStartResponse(
-    const std::string& response) {
+void CloudPrintRequester::ParseRegisterStart(const std::string& response) {
   std::string polling_url;
   std::string registration_token;
   std::string complete_invite_url;
@@ -224,8 +288,7 @@ void CloudPrintRequester::ParseRegisterStartResponse(
                                                complete_invite_url, device_id);
 }
 
-void CloudPrintRequester::ParseRegisterCompleteResponse(
-    const std::string& response) {
+void CloudPrintRequester::ParseRegisterComplete(const std::string& response) {
   std::string authorization_code;
 
   bool success = cloud_print_response_parser::ParseRegisterCompleteResponse(
@@ -242,3 +305,50 @@ void CloudPrintRequester::ParseRegisterCompleteResponse(
                                kGaiaMaxRetries, this);
 }
 
+void CloudPrintRequester::ParseFetch(const std::string& response) {
+  LOG_IF(INFO, kFunctionVebose) << "Function: " << __FUNCTION__;
+  std::vector<Printjob> list;
+  bool success = cloud_print_response_parser::ParseFetchResponse(
+      response,
+      base::Bind(&CloudPrintRequester::Delegate::OnServerError,

[Vitaly Buka (NO REVIEWS), 2013/07/22 03:57:31]

same issue with delegate_

[maksymb, 2013/07/22 22:56:53]

No, this callback can be called only in this function.

+                 base::Unretained(delegate_)),
+      &list);
+
+  if (!success)
+    return;
+
+  delegate_->OnPrintjobsAvailable(list);
+}
+
+void CloudPrintRequester::ParseGetPrintjobTicket(const std::string& response) {
+  LOG_IF(INFO, kFunctionVebose) << "Function: " << __FUNCTION__;
+  current_printjob_->ticket = response;
+
+  DCHECK(current_printjob_);
+  request_ = CreateGet(GURL(current_printjob_->file_url));
+  request_->AddHeader("Accept: \"application/pdf\"");
+  request_->Run(base::Bind(&CloudPrintRequester::ParseGetPrintjobData,
+                       base::Unretained(this)));
+}
+
+void CloudPrintRequester::ParseGetPrintjobData(const std::string& response) {
+  LOG_IF(INFO, kFunctionVebose) << "Function: " << __FUNCTION__;
+  current_printjob_->file = response;
+  DCHECK(current_printjob_);
+  delegate_->OnPrintjobDownloaded(*current_printjob_);
+}
+
+void CloudPrintRequester::ParsePrintjobDone(const std::string& response) {
+  LOG_IF(INFO, kFunctionVebose) << "Function: " << __FUNCTION__;
+  current_printjob_.reset();
+  delegate_->OnPrintjobDone();
+}
+
+void CloudPrintRequester::ParsePrintjobInProgress(const std::string& response) {
+  LOG_IF(INFO, kFunctionVebose) << "Function: " << __FUNCTION__;
+  DCHECK(current_printjob_);
+  request_ = CreateGet(GURL(current_printjob_->ticket_url));
+  request_->Run(base::Bind(&CloudPrintRequester::ParseGetPrintjobTicket,
+                           base::Unretained(this)));
+}
+