Print support for Windows Metro...

printing/printed_document.cc

 // Copyright (c) 2011 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 "printing/printed_document.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 28 matching lines @@
 
 base::LazyInstance<PrintDebugDumpPath> g_debug_dump_info =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 namespace printing {
 
 PrintedDocument::PrintedDocument(const PrintSettings& settings,
                                  PrintedPagesSource* source,
+                                 Delegate* delegate,
                                  int cookie)
     : mutable_(source),
-      immutable_(settings, source, cookie) {
+      immutable_(settings, source, delegate, cookie) {
 
+#if !defined(OS_WIN)
+  DCHECK(immutable_.delegate_ == NULL) <<
+      "Delegate is only supported on Windows for now";

[Albert Bodenhamer, 2012/06/15 18:41:24]

Is there any reason you need this?  The basic delegate concept is portable.  The
fact that the only implementer of this interface is Metro isn't something that
needs to be enforced is it?

[MAD, 2012/06/19 14:24:10]

Yeah, I wanted to avoid people trying to use it on other platforms where it's
not implemented... Will change that...

[MAD, 2012/06/28 15:48:14]

Done.

+#endif
   // Records the expected page count if a range is setup.
   if (!settings.ranges.empty()) {
     // If there is a range, set the number of page
     for (unsigned i = 0; i < settings.ranges.size(); ++i) {
       const PageRange& range = settings.ranges[i];
       mutable_.expected_page_count_ += range.to - range.from + 1;
+      if (immutable_.delegate_)
+        immutable_.delegate_->SetPageCount(mutable_.expected_page_count_);
     }
   }
 }
 
 PrintedDocument::~PrintedDocument() {
 }
 
 void PrintedDocument::SetPage(int page_number,
                               Metafile* metafile,
                               double shrink,
@@ skipping 79 matching lines @@
   }
   return total;
 }
 
 void PrintedDocument::set_page_count(int max_page) {
   base::AutoLock lock(lock_);
   DCHECK_EQ(0, mutable_.page_count_);
   mutable_.page_count_ = max_page;
   if (immutable_.settings_.ranges.empty()) {
     mutable_.expected_page_count_ = max_page;
+    if (immutable_.delegate_)
+      immutable_.delegate_->SetPageCount(mutable_.expected_page_count_);
   } else {
     // If there is a range, don't bother since expected_page_count_ is already
     // initialized.
     DCHECK_NE(mutable_.expected_page_count_, 0);
   }
 }
 
 int PrintedDocument::page_count() const {
   base::AutoLock lock(lock_);
   return mutable_.page_count_;
@@ skipping 39 matching lines @@
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
   first_page = INT_MAX;
 #endif
 }
 
 PrintedDocument::Mutable::~Mutable() {
 }
 
 PrintedDocument::Immutable::Immutable(const PrintSettings& settings,
                                       PrintedPagesSource* source,
+                                      Delegate* delegate,
                                       int cookie)
     : settings_(settings),
       source_message_loop_(MessageLoop::current()),
       name_(source->RenderSourceName()),
+      delegate_(delegate),
       cookie_(cookie) {
 }
 
 PrintedDocument::Immutable::~Immutable() {
 }
 
 #if defined(OS_POSIX) && defined(USE_AURA)
 // This function is not used on aura linux/chromeos.
 void PrintedDocument::RenderPrintedPage(const PrintedPage& page,
                                         PrintingContext* context) const {
 }
 #endif
 
 }  // namespace printing