Move PDF to PWG conversion into PrivetLocalPrintOperationImpl

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"
 #include "base/message_loop/message_loop.h"
 #include "base/rand_util.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 {
@@ skipping 343 matching lines @@
     const PrivetURLFetcher::TokenCallback& callback) {
   privet_client_->RefreshPrivetToken(callback);
 }
 
 PrivetLocalPrintOperationImpl::PrivetLocalPrintOperationImpl(
     PrivetHTTPClientImpl* privet_client,
     PrivetLocalPrintOperation::Delegate* delegate)
     : privet_client_(privet_client), delegate_(delegate),
       use_pdf_(false), has_capabilities_(false), has_extended_workflow_(false),
       started_(false), offline_(false), invalid_job_retries_(0),
+      pwg_raster_converter_(PWGRasterConverter::CreateDefault()),
       weak_factory_(this) {
 }
 
 PrivetLocalPrintOperationImpl::~PrivetLocalPrintOperationImpl() {
 }
 
 void PrivetLocalPrintOperationImpl::Start() {
   DCHECK(!started_);
 
   // We need to get the /info response so we can know which APIs are available.
@@ skipping 39 matching lines @@
   }
 }
 
 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);
+    StartConvertToPWG();
   }
 }
 
 void PrivetLocalPrintOperationImpl::GetCapabilities() {
   current_response_ = base::Bind(
       &PrivetLocalPrintOperationImpl::OnCapabilitiesResponse,
       base::Unretained(this));
 
   url_fetcher_= privet_client_->CreateURLFetcher(
       CreatePrivetURL(kPrivetCapabilitiesPath), net::URLFetcher::GET, this);
@@ skipping 41 matching lines @@
 
   if (offline_) {
     url = net::AppendQueryParameter(url,
                                     kPrivetURLKeyOffline,
                                     kPrivetURLValueOffline);
   }
 
   url_fetcher_= privet_client_->CreateURLFetcher(
       url, net::URLFetcher::POST, this);
 
-  std::string content_type =
-      use_pdf_ ? kPrivetContentTypePDF : kPrivetContentTypePWGRaster;
-
-  DCHECK(!data_.empty() || !data_file_.empty());
-
-  if (!data_file_.empty()) {
-    url_fetcher_->SetUploadFilePath(content_type, data_file_);
+  if (!use_pdf_) {
+    url_fetcher_->SetUploadFilePath(kPrivetContentTypePWGRaster,
+                                    pwg_file_path_);
   } else {
-    url_fetcher_->SetUploadData(content_type, data_);
+    // TODO(noamsml): Move to file-based upload data?
+    std::string data_str((const char*)data_->front(), data_->size());
+    url_fetcher_->SetUploadData(kPrivetContentTypePDF, data_str);
   }
 
   url_fetcher_->Start();
 }
 
+void PrivetLocalPrintOperationImpl::StartPrinting() {
+  if (has_extended_workflow_ && !ticket_.empty() && jobid_.empty()) {
+    DoCreatejob();
+  } else {
+    DoSubmitdoc();
+  }
+}
+
+void PrivetLocalPrintOperationImpl::StartConvertToPWG() {
+  pwg_raster_converter_->SetResultCallback(
+      base::Bind(&PrivetLocalPrintOperationImpl::OnPWGRasterConverted,
+                 base::Unretained(this)));
+  pwg_raster_converter_->SetPDFData(data_);
+  pwg_raster_converter_->Start();
+}
+
 void PrivetLocalPrintOperationImpl::OnCapabilitiesResponse(
     bool has_error,
     const base::DictionaryValue* value) {
   if (has_error) {
     delegate_->OnPrivetPrintingError(this, 200);
     return;
   }
 
   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;
 
       if (supported_content_types->GetDictionary(i, &content_type_value) &&
           content_type_value->GetString(kPrivetCDDKeyContentType,
                                         &content_type) &&
           (content_type == kPrivetContentTypePDF ||
            content_type == kPrivetContentTypeAny) ) {
         use_pdf_ = true;
       }
     }
   }
 
-  if (use_pdf_)
-    delegate_->OnPrivetPrintingRequestPDF(this);
-  else
-    delegate_->OnPrivetPrintingRequestPWGRaster(this);
+  if (use_pdf_) {
+    StartPrinting();
+  } else {
+    StartConvertToPWG();
+  }
 }
 
 void PrivetLocalPrintOperationImpl::OnSubmitdocResponse(
     bool has_error,
     const base::DictionaryValue* value) {
   std::string error;
   // This error is only relevant in the case of extended workflow:
   // If the print job ID is invalid, retry createjob and submitdoc,
   // rather than simply retrying the current request.
   if (has_error && value->GetString(kPrivetKeyError, &error)) {
@@ skipping 11 matching lines @@
       timeout = static_cast<int>(timeout * random_scaling_factor);
 
       timeout = std::max(timeout, kPrivetMinimumTimeout);
 
       base::MessageLoop::current()->PostDelayedTask(
           FROM_HERE, base::Bind(&PrivetLocalPrintOperationImpl::DoCreatejob,
                                 weak_factory_.GetWeakPtr()),
           base::TimeDelta::FromSeconds(timeout));
     } else if (use_pdf_ && error == kPrivetErrorInvalidDocumentType) {
       use_pdf_ = false;
-      delegate_->OnPrivetPrintingRequestPWGRaster(this);
+      StartConvertToPWG();
     } else {
       delegate_->OnPrivetPrintingError(this, 200);
     }
 
     return;
   }
 
   // If we've gotten this far, there are no errors, so we've effectively
   // succeeded.
   delegate_->OnPrivetPrintingDone(this);
 }
 
 void PrivetLocalPrintOperationImpl::OnCreatejobResponse(
     bool has_error,
     const base::DictionaryValue* value) {
   if (has_error) {
     delegate_->OnPrivetPrintingError(this, 200);
     return;
   }
 
   // Try to get job ID from value. If not, jobid_ will be empty and we will use
   // simple printing.
   value->GetString(kPrivetKeyJobID, &jobid_);
 
   DoSubmitdoc();
 }
 
+void PrivetLocalPrintOperationImpl::OnPWGRasterConverted(
+    bool success,
+    const base::FilePath& pwg_file_path) {
+  if (!success) {
+    delegate_->OnPrivetPrintingError(this, -1);
+    return;
+  }
+
+  DCHECK(!pwg_file_path.empty());
+
+  pwg_file_path_ = pwg_file_path;
+  StartPrinting();
+}
+
 PrivetHTTPClient* PrivetLocalPrintOperationImpl::GetHTTPClient() {
   return privet_client_;
 }
 
 void PrivetLocalPrintOperationImpl::OnError(
     PrivetURLFetcher* fetcher,
     PrivetURLFetcher::ErrorType error) {
   delegate_->OnPrivetPrintingError(this, -1);
 }
 
 void PrivetLocalPrintOperationImpl::OnParsedJson(
     PrivetURLFetcher* fetcher,
     const base::DictionaryValue* value,
     bool has_error) {
   DCHECK(!current_response_.is_null());
   current_response_.Run(has_error, value);
 }
 
 void PrivetLocalPrintOperationImpl::OnNeedPrivetToken(
     PrivetURLFetcher* fetcher,
     const PrivetURLFetcher::TokenCallback& callback) {
   privet_client_->RefreshPrivetToken(callback);
 }
 
-void PrivetLocalPrintOperationImpl::SendData(const std::string& data) {
-  DCHECK(started_);
-  DCHECK(data_file_.empty());
+void PrivetLocalPrintOperationImpl::SetData(
+    scoped_refptr<base::RefCountedBytes> data) {
+  DCHECK(!started_);
   data_ = data;
-
-  SendDataInternal();
-}
-
-void PrivetLocalPrintOperationImpl::SendDataFile(
-    const base::FilePath& data_file) {
-  DCHECK(started_);
-  DCHECK(data_.empty());
-  data_file_ = data_file;
-
-  SendDataInternal();
 }
 
 void PrivetLocalPrintOperationImpl::SetTicket(const std::string& ticket) {
   DCHECK(!started_);
   ticket_ = ticket;
 }
 
 void PrivetLocalPrintOperationImpl::SetUsername(const std::string& user) {
   DCHECK(!started_);
   user_= user;
 }
 
 void PrivetLocalPrintOperationImpl::SetJobname(const std::string& jobname) {
   DCHECK(!started_);
   jobname_ = jobname;
 }
 
 void PrivetLocalPrintOperationImpl::SetOffline(bool offline) {
   DCHECK(!started_);
   offline_ = offline;
 }
 
-void PrivetLocalPrintOperationImpl::SendDataInternal() {
-  if (has_extended_workflow_ && !ticket_.empty() && jobid_.empty()) {
-    DoCreatejob();
-  } else {
-    DoSubmitdoc();
-  }
+void PrivetLocalPrintOperationImpl::SetPWGRasterConverterForTesting(
+    scoped_ptr<PWGRasterConverter> pwg_raster_converter) {
+  pwg_raster_converter_ = pwg_raster_converter.Pass();
 }
 
 PrivetHTTPClientImpl::PrivetHTTPClientImpl(
     const std::string& name,
     const net::HostPortPair& host_port,
     net::URLRequestContextGetter* request_context)
     : name_(name),
       fetcher_factory_(request_context),
       host_port_(host_port) {
 }
@@ skipping 87 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