Make the PDF viewer background color a property of the instance.

pdf/pdfium/pdfium_engine.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 "pdf/pdfium/pdfium_engine.h"
 
 #include <math.h>
 
 #include "base/json/json_writer.h"
 #include "base/logging.h"
@@ skipping 582 matching lines @@
       last_page_to_search_(-1),
       last_character_index_to_search_(-1),
       permissions_(0),
       fpdf_availability_(NULL),
       next_timer_id_(0),
       last_page_mouse_down_(-1),
       first_visible_page_(-1),
       most_visible_page_(-1),
       called_do_document_action_(false),
       render_grayscale_(false),
-      background_color_(0),
       progressive_paint_timeout_(0),
       getting_password_(false) {
   find_factory_.Initialize(this);
   password_factory_.Initialize(this);
 
   file_access_.m_FileLen = 0;
   file_access_.m_GetBlock = &GetBlock;
   file_access_.m_Param = &doc_loader_;
 
   file_availability_.version = 1;
@@ skipping 1747 matching lines @@
     if (pages_[i]->available()) {
       selection_.push_back(PDFiumRange(pages_[i], 0,
                            pages_[i]->GetCharCount()));
     }
 }
 
 int PDFiumEngine::GetNumberOfPages() {
   return pages_.size();
 }
 
-uint32 PDFiumEngine::GetBackgroundColor() {
-  return background_color_;
-}
-
-void PDFiumEngine::SetBackgroundColor(uint32 background_color) {
-  background_color_ = background_color;
-}
-
 pp::VarArray PDFiumEngine::GetBookmarks() {
   pp::VarDictionary dict = TraverseBookmarks(doc_, NULL);
   // The root bookmark contains no useful information.
   return pp::VarArray(dict.Get(pp::Var("children")));
 }
 
 int PDFiumEngine::GetNamedDestinationPage(const std::string& destination) {
   // Look for the destination.
   FPDF_DEST dest = FPDF_GetNamedDestByName(doc_, destination.c_str());
   if (!dest) {
@@ skipping 551 matching lines @@
   if (page_rect.x() > 0) {
     pp::Rect left(0,
                   page_rect.y() - kPageShadowTop,
                   page_rect.x() - kPageShadowLeft,
                   page_rect.height() + kPageShadowTop +
                       kPageShadowBottom + kPageSeparatorThickness);
     left = GetScreenRect(left).Intersect(dirty_in_screen);
 
     FPDFBitmap_FillRect(bitmap, left.x() - dirty_in_screen.x(),
                         left.y() - dirty_in_screen.y(), left.width(),
-                        left.height(), background_color_);
+                        left.height(), client_->GetBackgroundColor());
   }
 
   if (page_rect.right() < document_size_.width()) {
     pp::Rect right(page_rect.right() + kPageShadowRight,
                    page_rect.y() - kPageShadowTop,
                    document_size_.width() - page_rect.right() -
                       kPageShadowRight,
                    page_rect.height() + kPageShadowTop +
                        kPageShadowBottom + kPageSeparatorThickness);
     right = GetScreenRect(right).Intersect(dirty_in_screen);
 
     FPDFBitmap_FillRect(bitmap, right.x() - dirty_in_screen.x(),
                         right.y() - dirty_in_screen.y(), right.width(),
-                        right.height(), background_color_);
+                        right.height(), client_->GetBackgroundColor());
   }
 
   // Paint separator.
   pp::Rect bottom(page_rect.x() - kPageShadowLeft,
                   page_rect.bottom() + kPageShadowBottom,
                   page_rect.width() + kPageShadowLeft + kPageShadowRight,
                   kPageSeparatorThickness);
   bottom = GetScreenRect(bottom).Intersect(dirty_in_screen);
 
   FPDFBitmap_FillRect(bitmap, bottom.x() - dirty_in_screen.x(),
                       bottom.y() - dirty_in_screen.y(), bottom.width(),
-                      bottom.height(), background_color_);
+                      bottom.height(), client_->GetBackgroundColor());
 }
 
 void PDFiumEngine::PaintPageShadow(int progressive_index,
                                    pp::ImageData* image_data) {
   DCHECK_GE(progressive_index, 0);
   DCHECK_LT(static_cast<size_t>(progressive_index), progressive_paints_.size());
   DCHECK(image_data);
 
   int page_index = progressive_paints_[progressive_index].page_index;
   pp::Rect dirty_in_screen = progressive_paints_[progressive_index].rect;
@@ skipping 431 matching lines @@
   const double factor = 0.5;
   uint32 depth = std::max(
       std::max(page_rect.x() - shadow_rect.x(),
                page_rect.y() - shadow_rect.y()),
       std::max(shadow_rect.right() - page_rect.right(),
                shadow_rect.bottom() - page_rect.bottom()));
   depth = static_cast<uint32>(depth * 1.5) + 1;
 
   // We need to check depth only to verify our copy of shadow matrix is correct.
   if (!page_shadow_.get() || page_shadow_->depth() != depth)
-    page_shadow_.reset(new ShadowMatrix(depth, factor, background_color_));
+    page_shadow_.reset(new ShadowMatrix(depth, factor,
+                                        client_->GetBackgroundColor()));
 
   DCHECK(!image_data->is_null());
   DrawShadow(image_data, shadow_rect, page_rect, clip_rect, *page_shadow_);
 }
 
 void PDFiumEngine::GetRegion(const pp::Point& location,
                              pp::ImageData* image_data,
                              void** region,
                              int* stride) const {
   if (image_data->is_null()) {
@@ skipping 589 matching lines @@
     double* height) {
   FPDF_DOCUMENT doc = FPDF_LoadMemDocument(pdf_buffer, pdf_buffer_size, NULL);
   if (!doc)
     return false;
   bool success = FPDF_GetPageSizeByIndex(doc, page_number, width, height) != 0;
   FPDF_CloseDocument(doc);
   return success;
 }
 
 }  // namespace chrome_pdf