Fixes for re-enabling more MSVC level 4 warnings: pdf/ edition

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 37 matching lines @@
 #define kPageShadowTop    3
 #define kPageShadowBottom 7
 #define kPageShadowLeft   5
 #define kPageShadowRight  5
 
 #define kPageSeparatorThickness 4
 #define kHighlightColorR 153
 #define kHighlightColorG 193
 #define kHighlightColorB 218
 
-#define kPendingPageColorR 238
-#define kPendingPageColorG 238
-#define kPendingPageColorB 238
-#define kPendingPageColorA 255
+const uint32 kPendingPageColor = 0xFFEEEEEE;
 
 #define kFormHighlightColor 0xFFE4DD
 #define kFormHighlightAlpha 100
 
 #define kMaxPasswordTries 3
 
 // See Table 3.20 in
 // http://www.adobe.com/devnet/acrobat/pdfs/pdf_reference_1-7.pdf
 #define kPDFPermissionPrintLowQualityMask  1 << 2
 #define kPDFPermissionPrintHighQualityMask 1 << 11
@@ skipping 979 matching lines @@
                                         false);
 
     FPDF_BITMAP bitmap = FPDFBitmap_CreateEx(bitmap_size.width(),
                                              bitmap_size.height(),
                                              FPDFBitmap_BGRx,
                                              image.data(),
                                              image.stride());
 
     // Clear the bitmap
     FPDFBitmap_FillRect(bitmap, 0, 0, bitmap_size.width(),
-                        bitmap_size.height(), 255, 255, 255, 255);
+                        bitmap_size.height(), 0xFFFFFFFF);
 
     pp::Rect page_rect = pages_to_print[i].rect();
     FPDF_RenderPageBitmap(bitmap, pages_to_print[i].GetPrintPage(),
                           page_rect.x(), page_rect.y(),
                           page_rect.width(), page_rect.height(),
                           print_settings.orientation,
                           FPDF_ANNOT | FPDF_PRINTING | FPDF_NO_CATCH);
 
     double ratio_x = (static_cast<double>(bitmap_size.width()) *
                           kPointsPerInch) / print_settings.dpi;
@@ skipping 852 matching lines @@
 pp::Rect PDFiumEngine::GetPageContentsRect(int index) {
   return GetScreenRect(pages_[index]->rect());
 }
 
 void PDFiumEngine::PaintThumbnail(pp::ImageData* image_data, int index) {
   FPDF_BITMAP bitmap = FPDFBitmap_CreateEx(
       image_data->size().width(), image_data->size().height(),
       FPDFBitmap_BGRx, image_data->data(), image_data->stride());
 
   if (pages_[index]->available()) {
-    FPDFBitmap_FillRect(
-        bitmap, 0, 0, image_data->size().width(), image_data->size().height(),
-        255, 255, 255, 255);
+    FPDFBitmap_FillRect(bitmap, 0, 0, image_data->size().width(),
+                        image_data->size().height(), 0xFFFFFFFF);
 
     FPDF_RenderPageBitmap(
         bitmap, pages_[index]->GetPage(), 0, 0, image_data->size().width(),
         image_data->size().height(), 0, GetRenderingFlags());
   } else {
-    FPDFBitmap_FillRect(
-        bitmap, 0, 0, image_data->size().width(), image_data->size().height(),
-        kPendingPageColorR, kPendingPageColorG, kPendingPageColorB,
-        kPendingPageColorA);
+    FPDFBitmap_FillRect(bitmap, 0, 0, image_data->size().width(),
+                        image_data->size().height(), kPendingPageColor);
   }
 
   FPDFBitmap_Destroy(bitmap);
 }
 
 void PDFiumEngine::SetGrayscale(bool grayscale) {
   render_grayscale_ = grayscale;
 }
 
 void PDFiumEngine::OnCallback(int id) {
@@ skipping 383 matching lines @@
   if (progressive_paints_[progressive_index].bitmap) {
     rv = FPDF_RenderPage_Continue(
         pages_[page_index]->GetPage(), static_cast<IFSDK_PAUSE*>(this));
   } else {
     pp::Rect dirty = progressive_paints_[progressive_index].rect;
     progressive_paints_[progressive_index].bitmap = CreateBitmap(dirty,
                                                                  image_data);
     int start_x, start_y, size_x, size_y;
     GetPDFiumRect(
         page_index, dirty, &start_x, &start_y, &size_x, &size_y);
-    FPDFBitmap_FillRect(
-        progressive_paints_[progressive_index].bitmap, start_x, start_y, size_x,
-        size_y, 255, 255, 255, 255);
+    FPDFBitmap_FillRect(progressive_paints_[progressive_index].bitmap, start_x,
+                        start_y, size_x, size_y, 0xFFFFFFFF);
     rv = FPDF_RenderPageBitmap_Start(
         progressive_paints_[progressive_index].bitmap,
         pages_[page_index]->GetPage(), start_x, start_y, size_x, size_y,
         current_rotation_,
         GetRenderingFlags(), static_cast<IFSDK_PAUSE*>(this));
   }
   return rv != FPDF_RENDER_TOBECOUNTINUED;
 }
 
 void PDFiumEngine::FinishPaint(int progressive_index,
@@ skipping 39 matching lines @@
 
   pp::Rect page_rect = pages_[page_index]->rect();
   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(),
-        kBackgroundColorR, kBackgroundColorG, kBackgroundColorB,
-        kBackgroundColorA);
+    FPDFBitmap_FillRect(bitmap, left.x() - dirty_in_screen.x(),
+                        left.y() - dirty_in_screen.y(), left.width(),
+                        left.height(), kBackgroundColor);
   }
 
   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(),
-        kBackgroundColorR, kBackgroundColorG, kBackgroundColorB,
-        kBackgroundColorA);
+    FPDFBitmap_FillRect(bitmap, right.x() - dirty_in_screen.x(),
+                        right.y() - dirty_in_screen.y(), right.width(),
+                        right.height(), kBackgroundColor);
   }
 
   // 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(),
-      kBackgroundColorR, kBackgroundColorG, kBackgroundColorB,
-      kBackgroundColorA);
+  FPDFBitmap_FillRect(bitmap, bottom.x() - dirty_in_screen.x(),
+                      bottom.y() - dirty_in_screen.y(), bottom.width(),
+                      bottom.height(), kBackgroundColor);
 }
 
 void PDFiumEngine::PaintPageShadow(int progressive_index,
                                    pp::ImageData* image_data) {
   int page_index = progressive_paints_[progressive_index].page_index;
   pp::Rect dirty_in_screen = progressive_paints_[progressive_index].rect;
   pp::Rect page_rect = pages_[page_index]->rect();
   pp::Rect shadow_rect(page_rect);
   shadow_rect.Inset(-kPageShadowLeft, -kPageShadowTop,
                     -kPageShadowRight, -kPageShadowBottom);
@@ skipping 52 matching lines @@
   form_highlights_.clear();
 }
 
 void PDFiumEngine::PaintUnavailablePage(int page_index,
                                         const pp::Rect& dirty,
                                         pp::ImageData* image_data) {
   int start_x, start_y, size_x, size_y;
   GetPDFiumRect(page_index, dirty, &start_x, &start_y, &size_x, &size_y);
   FPDF_BITMAP bitmap = CreateBitmap(dirty, image_data);
   FPDFBitmap_FillRect(bitmap, start_x, start_y, size_x, size_y,
-      kPendingPageColorR, kPendingPageColorG, kPendingPageColorB,
-      kPendingPageColorA);
+                      kPendingPageColor);
 
   pp::Rect loading_text_in_screen(
       pages_[page_index]->rect().width() / 2,
       pages_[page_index]->rect().y() + kLoadingTextVerticalOffset, 0, 0);
   loading_text_in_screen = GetScreenRect(loading_text_in_screen);
   FPDFBitmap_Destroy(bitmap);
 }
 
 int PDFiumEngine::GetProgressiveIndex(int page_index) const {
   for (size_t i = 0; i < progressive_paints_.size(); ++i) {
@@ skipping 280 matching lines @@
   page_rect.Offset(page_offset_);
 
   pp::Rect shadow_rect(shadow_rc);
   shadow_rect.Offset(page_offset_);
 
   pp::Rect clip_rect(clip_rc);
   clip_rect.Offset(page_offset_);
 
   // Page drop shadow parameters.
   const double factor = 0.5;
-  const uint32 background = (kBackgroundColorA << 24) |
-                            (kBackgroundColorR << 16) |
-                            (kBackgroundColorG << 8) |
-                            kBackgroundColorB;
   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));
+    page_shadow_.reset(new ShadowMatrix(depth, factor, kBackgroundColor));
 
   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 463 matching lines @@
   // because of the code to talk Postscript directly to the printer if
   // the printer supports this. Need to discuss this with PDFium. For now,
   // render to a bitmap and then blit the bitmap to the DC if we have been
   // supplied a printer DC.
   int device_type = GetDeviceCaps(dc, TECHNOLOGY);
   if (use_bitmap ||
       (device_type == DT_RASPRINTER) || (device_type == DT_PLOTTER)) {
     FPDF_BITMAP bitmap = FPDFBitmap_Create(dest.width(), dest.height(),
                                            FPDFBitmap_BGRx);
       // Clear the bitmap
-    FPDFBitmap_FillRect(bitmap, 0, 0, dest.width(), dest.height(), 255, 255,
-                        255, 255);
+    FPDFBitmap_FillRect(bitmap, 0, 0, dest.width(), dest.height(), 0xFFFFFFFF);
     FPDF_RenderPageBitmap(
         bitmap, page, 0, 0, dest.width(), dest.height(), rotate,
         FPDF_ANNOT | FPDF_PRINTING | FPDF_NO_CATCH);
     int stride = FPDFBitmap_GetStride(bitmap);
     BITMAPINFO bmi;
     memset(&bmi, 0, sizeof(bmi));
     bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
     bmi.bmiHeader.biWidth = dest.width();
     bmi.bmiHeader.biHeight = -dest.height();  // top-down image
     bmi.bmiHeader.biPlanes = 1;
@@ skipping 32 matching lines @@
 
   pp::Rect dest;
   int rotate = CalculatePosition(page, settings, &dest);
 
   FPDF_BITMAP bitmap =
       FPDFBitmap_CreateEx(settings.bounds.width(), settings.bounds.height(),
                           FPDFBitmap_BGRA, bitmap_buffer,
                           settings.bounds.width() * 4);
   // Clear the bitmap
   FPDFBitmap_FillRect(bitmap, 0, 0, settings.bounds.width(),
-                      settings.bounds.height(), 255, 255, 255, 255);
+                      settings.bounds.height(), 0xFFFFFFFF);
   // Shift top-left corner of bounds to (0, 0) if it's not there.
   dest.set_point(dest.point() - settings.bounds.point());
   FPDF_RenderPageBitmap(
       bitmap, page, dest.x(), dest.y(), dest.width(), dest.height(), rotate,
       FPDF_ANNOT | FPDF_PRINTING | FPDF_NO_CATCH);
   FPDFBitmap_Destroy(bitmap);
   FPDF_ClosePage(page);
   FPDF_CloseDocument(doc);
   return true;
 }
@@ skipping 18 matching lines @@
       if (page_width > *max_page_width) {
         *max_page_width = page_width;
       }
     }
   }
   FPDF_CloseDocument(doc);
   return true;
 }
 
 }  // namespace chrome_pdf