Print support for Windows Metro...

chrome/browser/printing/print_job_worker.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 "chrome/browser/printing/print_job_worker.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
@@ skipping 51 matching lines @@
   // on the I/O thread.
   DCHECK_EQ(owner_->message_loop(), MessageLoop::current());
   Stop();
 }
 
 void PrintJobWorker::SetNewOwner(PrintJobWorkerOwner* new_owner) {
   DCHECK(page_number_ == PageNumber::npos());
   owner_ = new_owner;
 }
 
+void PrintJobWorker::SetPrintDestination(
+    PrintDestinationInterface* destination) {
+  DCHECK(destination_.get() == NULL);

[robertshield, 2012/06/28 17:48:54]

Why is this DCHECK present? 

If it needs to be here, please document in the header that this method must only
be called once.

[MAD, 2012/06/28 19:05:51]

It was just for debugging, forgot to remove... Thanks!
Done.

+  destination_ = destination;
+}
+
 void PrintJobWorker::GetSettings(bool ask_user_for_settings,
                                  gfx::NativeView parent_view,
                                  int document_page_count,
                                  bool has_selection,
                                  MarginType margin_type) {
   DCHECK_EQ(message_loop(), MessageLoop::current());
   DCHECK_EQ(page_number_, PageNumber::npos());
 
   // Recursive task processing is needed for the dialog in case it needs to be
   // destroyed by a task.
   // TODO(thestig): This code is wrong. SetNestableTasksAllowed(true) is needed
   // on the thread where the PrintDlgEx is called, and definitely both calls
   // should happen on the same thread. See http://crbug.com/73466
   // MessageLoop::current()->SetNestableTasksAllowed(true);
   printing_context_->set_margin_type(margin_type);
 
-  if (ask_user_for_settings) {
+  // When we delegate to a destination, we don't ask the user for settings.
+  // TODO(mad): Ask the destination for settings.
+  if (ask_user_for_settings && destination_.get() == NULL) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&HoldRefCallback, make_scoped_refptr(owner_),
                    base::Bind(&PrintJobWorker::GetSettingsWithUI,
                               base::Unretained(this), parent_view,
                               document_page_count, has_selection)));
   } else {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&HoldRefCallback, make_scoped_refptr(owner_),
@@ skipping 135 matching lines @@
     // Find first page to print.
     int page_count = document_->page_count();
     if (!page_count) {
       // We still don't know how many pages the document contains. We can't
       // start to print the document yet since the header/footer may refer to
       // the document's page count.
       return;
     }
     // We have enough information to initialize page_number_.
     page_number_.Init(document_->settings(), page_count);
+    if (destination_.get() != NULL)
+      destination_->SetPageCount(page_count);
   }
   DCHECK_NE(page_number_, PageNumber::npos());
 
   while (true) {
     // Is the page available?
     scoped_refptr<PrintedPage> page;
     if (!document_->GetPage(page_number_.ToInt(), &page)) {
       // We need to wait for the page to be available.
       MessageLoop::current()->PostDelayedTask(
           FROM_HERE,
@@ skipping 47 matching lines @@
       FROM_HERE, base::Bind(NotificationCallback, make_scoped_refptr(owner_),
                             JobEventDetails::NEW_PAGE, document_,
                             make_scoped_refptr(page)));
 
   // Preprocess.
   if (printing_context_->NewPage() != PrintingContext::OK) {
     OnFailure();
     return;
   }
 
+  if (destination_.get() != NULL) {
+    std::vector<uint8> metabytes(page->metafile()->GetDataSize());
+    bool success = page->metafile()->GetData(
+        reinterpret_cast<void*>(&metabytes[0]), metabytes.size());
+    destination_->SetPageContent(
+        page->page_number(),
+        reinterpret_cast<void*>(&metabytes[0]),
+        metabytes.size());
+    return;
+  }
+
   // Actual printing.
 #if defined(OS_WIN) || defined(OS_MACOSX)
   document_->RenderPrintedPage(*page, printing_context_->context());
 #elif defined(OS_POSIX)
   document_->RenderPrintedPage(*page, printing_context_.get());
 #endif
 
   // Postprocess.
   if (printing_context_->PageDone() != PrintingContext::OK) {
     OnFailure();
@@ skipping 19 matching lines @@
                             JobEventDetails::FAILED, document_,
                             scoped_refptr<PrintedPage>()));
   Cancel();
 
   // Makes sure the variables are reinitialized.
   document_ = NULL;
   page_number_ = PageNumber::npos();
 }
 
 }  // namespace printing