Print only the focused frame. This makes more sense than trying to print all...

chrome/renderer/mock_printer.cc

 // Copyright (c) 2009 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/renderer/mock_printer.h"
 
 #include "base/file_util.h"
-#include "base/gfx/png_encoder.h"
 #include "base/logging.h"
-#include "base/md5.h"
 #include "base/shared_memory.h"
 #include "chrome/common/ipc_message_utils.h"
 #include "chrome/common/render_messages.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 MockPrinter::MockPrinter()
   : printable_width_(0),
     printable_height_(0),
     dpi_(72),
     max_shrink_(2.0),
@@ skipping 88 matching lines @@
 
 #if defined(OS_WIN)
   // Load the EMF data sent from a RenderView object and create a PageData
   // object.
   // We duplicate the given file handle when creating a base::SharedMemory
   // instance so that its destructor closes the copy.
   EXPECT_GT(params.data_size, 0U);
   base::SharedMemory emf_data(params.metafile_data_handle, true,
                               GetCurrentProcess());
   emf_data.Map(params.data_size);
-  MockPrinterPage* page_data = driver_.LoadSource(emf_data.memory(),
-                                                  params.data_size);
+  printing::NativeMetafile metafile;
+  metafile.CreateFromData(emf_data.memory(), params.data_size);
+  printing::Image image(metafile);
+  MockPrinterPage* page_data = new MockPrinterPage(emf_data.memory(),
+                                                   params.data_size,
+                                                   image);
   if (!page_data) {
     printer_status_ = PRINTER_ERROR;
     return;
   }
 
   scoped_refptr<MockPrinterPage> page(page_data);
   pages_.push_back(page);
 #endif
 
   // We finish printing a printing job.
   // Reset the job status and the printer status.
   ++page_number_;
   if (number_pages_ == page_number_)
     ResetPrinter();
 }
 
 int MockPrinter::GetPrintedPages() const {
   if (printer_status_ != PRINTER_READY)
     return -1;
   return page_number_;
 }
 
+const MockPrinterPage* MockPrinter::GetPrintedPage(size_t pageno) const {
+  if (pages_.size() > pageno)
+    return pages_[pageno];
+  else
+    return NULL;
+}
+
 int MockPrinter::GetWidth(size_t page) const {
   if (printer_status_ != PRINTER_READY || page >= pages_.size())
     return -1;
   return pages_[page]->width();
 }
 
 int MockPrinter::GetHeight(size_t page) const {
   if (printer_status_ != PRINTER_READY || page >= pages_.size())
     return -1;
   return pages_[page]->height();
 }
 
-bool MockPrinter::GetSourceChecksum(size_t page, std::string* checksum) const {
-  if (printer_status_ != PRINTER_READY || page >= pages_.size())
-    return false;
-  return GetChecksum(pages_[page]->source_data(), pages_[page]->source_size(),
-                     checksum);
-}
-
 bool MockPrinter::GetBitmapChecksum(size_t page, std::string* checksum) const {
   if (printer_status_ != PRINTER_READY || page >= pages_.size())
     return false;
-  return GetChecksum(pages_[page]->bitmap_data(), pages_[page]->bitmap_size(),
-                     checksum);
-}
-
-bool MockPrinter::GetBitmap(size_t page,
-                            const void** data,
-                            size_t* size) const {
-  if (printer_status_ != PRINTER_READY || page >= pages_.size())
-    return false;
-  *data = pages_[page]->bitmap_data();
-  *size = pages_[page]->bitmap_size();
+  *checksum = pages_[page]->image().checksum();
   return true;
 }
 
 bool MockPrinter::SaveSource(size_t page,
                              const std::wstring& filename) const {
   if (printer_status_ != PRINTER_READY || page >= pages_.size())
     return false;
   const uint8* source_data = pages_[page]->source_data();
   size_t source_size = pages_[page]->source_size();
   file_util::WriteFile(filename, reinterpret_cast<const char*>(source_data),
                        source_size);
   return true;
 }
 
 bool MockPrinter::SaveBitmap(size_t page,
                              const std::wstring& filename) const {
   if (printer_status_ != PRINTER_READY || page >= pages_.size())
     return false;
-  int width = pages_[page]->width();
-  int height = pages_[page]->height();
-  int row_byte_width = width * 4;
-  const uint8* bitmap_data = pages_[page]->bitmap_data();
-  std::vector<unsigned char> compressed;
-  PNGEncoder::Encode(bitmap_data,
-                     PNGEncoder::FORMAT_BGRA, width, height,
-                     row_byte_width, true, &compressed);
-  file_util::WriteFile(filename,
-                       reinterpret_cast<char*>(&*compressed.begin()),
-                       compressed.size());
+
+  pages_[page]->image().SaveToPng(filename);
   return true;
 }
 
 int MockPrinter::CreateDocumentCookie() {
   return ++current_document_cookie_;
 }
 
-bool MockPrinter::GetChecksum(const void* data,
-                              size_t size,
-                              std::string* checksum) const {
-  MD5Digest digest;
-  MD5Sum(data, size, &digest);
-  checksum->assign(HexEncode(&digest, sizeof(digest)));
-  return true;
-}