Initial support for /privet/printer/createjob

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 "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/local_discovery/privet_constants.h"
 #include "net/base/url_util.h"
 #include "url/gurl.h"
 
 namespace local_discovery {
 
 namespace {
 const char kUrlPlaceHolder[] = "http://host/";
 const char kPrivetRegisterActionArgName[] = "action";
 const char kPrivetRegisterUserArgName[] = "user";
 
 const char kPrivetURLKeyUser[] = "user";
 const char kPrivetURLKeyJobname[] = "jobname";
 const char kPrivetURLKeyOffline[] = "offline";
 const char kPrivetURLValueOffline[] = "1";
 
 const char kPrivetContentTypePDF[] = "application/pdf";
 const char kPrivetContentTypePWGRaster[] = "image/pwg-raster";
+const char kPrivetContentTypeCJT[] = "application/json";
 
 const char kPrivetCDDKeySupportedContentTypes[] =
     "printer.supported_content_type";
 
 const char kPrivetCDDKeyContentType[] = "content_type";
 
+const char kPrivetKeyJobID[] = "job_id";
+
 const int kPrivetCancelationTimeoutSeconds = 3;
 
 GURL CreatePrivetURL(const std::string& path) {
   GURL url(kUrlPlaceHolder);
   GURL::Replacements replacements;
   replacements.SetPathStr(path);
   return url.ReplaceComponents(replacements);
 }
 
 GURL CreatePrivetRegisterURL(const std::string& action,
@@ skipping 314 matching lines @@
       use_pdf_(false), has_capabilities_(false), has_extended_workflow_(false),
       started_(false), offline_(false) {
 }
 
 PrivetLocalPrintOperationImpl::~PrivetLocalPrintOperationImpl() {
 }
 
 void PrivetLocalPrintOperationImpl::Start() {
   DCHECK(!started_);
 
-  current_request_ =
-      base::Bind(&PrivetLocalPrintOperationImpl::StartInitialRequest,
-                 base::Unretained(this));
-
   // We need to get the /info response so we can know which APIs are available.
   // TODO(noamsml): Use cached info when available.
   info_operation_ = privet_client_->CreateInfoOperation(this);
   info_operation_->Start();
 
   started_ = true;
 }
 
-void PrivetLocalPrintOperationImpl::StartCurrentRequest() {
-  DCHECK(!current_request_.is_null());
-  current_request_.Run();
-}
-
 void PrivetLocalPrintOperationImpl::OnPrivetInfoDone(
     PrivetInfoOperation* operation,
     int http_code,
     const base::DictionaryValue* value) {
   if (value && !value->HasKey(kPrivetKeyError)) {
     has_capabilities_ = false;
     has_extended_workflow_ = false;
     bool has_printing = false;
 
     const base::ListValue* api_list;
     if (value->GetList(kPrivetInfoKeyAPIList, &api_list)) {
       for (size_t i = 0; i < api_list->GetSize(); i++) {
         std::string api;
         api_list->GetString(i, &api);
         if (api == kPrivetCapabilitiesPath) {
           has_capabilities_ = true;
         } else if (api == kPrivetSubmitdocPath) {
           has_printing = true;
         } else if (api == kPrivetCreatejobPath) {
           has_extended_workflow_ = true;
         }
       }
     }
 
     if (!has_printing) {
       delegate_->OnPrivetPrintingError(this, -1);
       return;
     }
 
-    StartCurrentRequest();
+    StartInitialRequest();
   } else {
     delegate_->OnPrivetPrintingError(this, http_code);
   }
 }
 
 void PrivetLocalPrintOperationImpl::StartInitialRequest() {
   if (has_capabilities_) {
     GetCapabilities();
   } else {
     // Since we have no capabiltties, the only reasonable format we can
     // request is PWG Raster.
     use_pdf_ = false;
     delegate_->OnPrivetPrintingRequestPWGRaster(this);
   }
 }
 
 void PrivetLocalPrintOperationImpl::GetCapabilities() {
   current_response_ = base::Bind(
-      &PrivetLocalPrintOperationImpl::OnCapabilities,
+      &PrivetLocalPrintOperationImpl::OnCapabilitiesResponse,
       base::Unretained(this));
 
   url_fetcher_= privet_client_->CreateURLFetcher(
       CreatePrivetURL(kPrivetCapabilitiesPath), net::URLFetcher::GET, this);
   url_fetcher_->DoNotRetryOnTransientError();
 
   url_fetcher_->Start();
 }
 
+void PrivetLocalPrintOperationImpl::DoCreatejob() {
+  current_response_ = base::Bind(
+      &PrivetLocalPrintOperationImpl::OnCreatejobResponse,
+      base::Unretained(this));
+
+  url_fetcher_= privet_client_->CreateURLFetcher(
+      CreatePrivetURL(kPrivetCreatejobPath), net::URLFetcher::POST, this);
+  url_fetcher_->SetUploadData(kPrivetContentTypeCJT, ticket_);
+
+  url_fetcher_->Start();
+}
+
 void PrivetLocalPrintOperationImpl::DoSubmitdoc() {
   current_response_ = base::Bind(
       &PrivetLocalPrintOperationImpl::OnSubmitdocResponse,
       base::Unretained(this));
 
   GURL url = CreatePrivetURL(kPrivetSubmitdocPath);
 
   if (!user_.empty()) {
     url = net::AppendQueryParameter(url,
                                     kPrivetURLKeyUser,
                                     user_);
   }
 
   if (!jobname_.empty()) {
     url = net::AppendQueryParameter(url,
                                     kPrivetURLKeyJobname,
                                     jobname_);
   }
 
+  if (!jobid_.empty()) {
+    url = net::AppendQueryParameter(url,
+                                    kPrivetKeyJobID,
+                                    jobid_);
+  }
+
   if (offline_) {
     url = net::AppendQueryParameter(url,
                                     kPrivetURLKeyOffline,
                                     kPrivetURLValueOffline);
   }
 
   url_fetcher_= privet_client_->CreateURLFetcher(
       url, net::URLFetcher::POST, this);
 
   DCHECK(!data_.empty());
   url_fetcher_->SetUploadData(
       use_pdf_ ? kPrivetContentTypePDF : kPrivetContentTypePWGRaster,
       data_);
 
   url_fetcher_->Start();
 }
 
-void PrivetLocalPrintOperationImpl::OnCapabilities(
+void PrivetLocalPrintOperationImpl::OnCapabilitiesResponse(
     const base::DictionaryValue* value) {
   const base::ListValue* supported_content_types;
   use_pdf_ = false;
 
   if (value->GetList(kPrivetCDDKeySupportedContentTypes,
                      &supported_content_types)) {
     for (size_t i = 0; i < supported_content_types->GetSize();
          i++) {
       const base::DictionaryValue* content_type_value;
       std::string content_type;
@@ skipping 14 matching lines @@
 }
 
 void PrivetLocalPrintOperationImpl::OnSubmitdocResponse(
     const base::DictionaryValue* value) {
   // If we've gotten this far, there are no errors, so we've effectively
   // succeeded.
 
   delegate_->OnPrivetPrintingDone(this);
 }
 
+void PrivetLocalPrintOperationImpl::OnCreatejobResponse(
+    const base::DictionaryValue* value) {
+  // Try to get job ID from value. If not, jobid_ will be empty and we will use
+  // simple printing.
+  value->GetString(kPrivetKeyJobID, &jobid_);
+
+  DoSubmitdoc();
+}
+
 PrivetHTTPClient* PrivetLocalPrintOperationImpl::GetHTTPClient() {
   return privet_client_;
 }
 
 void PrivetLocalPrintOperationImpl::OnError(
     PrivetURLFetcher* fetcher,
     PrivetURLFetcher::ErrorType error) {
   delegate_->OnPrivetPrintingError(this, -1);
 }
 
@@ skipping 12 matching lines @@
 
 void PrivetLocalPrintOperationImpl::OnNeedPrivetToken(
     PrivetURLFetcher* fetcher,
     const PrivetURLFetcher::TokenCallback& callback) {
   privet_client_->RefreshPrivetToken(callback);
 }
 
 void PrivetLocalPrintOperationImpl::SendData(const std::string& data) {
   DCHECK(started_);
   data_ = data;
-  current_request_ = base::Bind(
-      &PrivetLocalPrintOperationImpl::DoSubmitdoc,
-      base::Unretained(this));
 
-  StartCurrentRequest();
+  if (has_extended_workflow_ && !ticket_.empty()) {
+    DoCreatejob();
+  } else {
+    DoSubmitdoc();
+  }
 }
 
 void PrivetLocalPrintOperationImpl::SetTicket(const std::string& ticket) {
   DCHECK(!started_);
   ticket_ = ticket;
 }
 
 void PrivetLocalPrintOperationImpl::SetUsername(const std::string& user) {
   DCHECK(!started_);
   user_= user;
@@ skipping 107 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);
   }
 }
 
 }  // namespace local_discovery