PDF: Cleanup more code now that it is completely out of process.

pdf/out_of_process_instance.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/out_of_process_instance.h"
 
 #include <algorithm>  // for min/max()
 #define _USE_MATH_DEFINES  // for M_PI
 #include <cmath>      // for log() and pow()
 #include <math.h>
@@ skipping 325 matching lines @@
   translated_strings.Set(kJSGetPasswordString,
       GetLocalizedString(PP_RESOURCESTRING_PDFGETPASSWORD));
   translated_strings.Set(kJSLoadingString,
       GetLocalizedString(PP_RESOURCESTRING_PDFLOADING));
   translated_strings.Set(kJSLoadFailedString,
       GetLocalizedString(PP_RESOURCESTRING_PDFLOAD_FAILED));
   PostMessage(translated_strings);
 
   text_input_.reset(new pp::TextInput_Dev(this));
 
-  const char* stream_url = NULL;
-  const char* original_url = NULL;
-  const char* headers = NULL;
+  const char* stream_url = nullptr;
+  const char* original_url = nullptr;
+  const char* headers = nullptr;
   bool is_material = false;
   for (uint32_t i = 0; i < argc; ++i) {
     if (strcmp(argn[i], "src") == 0)
       original_url = argv[i];
     else if (strcmp(argn[i], "stream-url") == 0)
       stream_url = argv[i];
     else if (strcmp(argn[i], "headers") == 0)
       headers = argv[i];
     else if (strcmp(argn[i], "is-material") == 0)
       is_material = true;
   }
 
   if (is_material)
     background_color_ = kBackgroundColorMaterial;
   else
     background_color_ = kBackgroundColor;
 
-  // TODO(raymes): This is a hack to ensure that if no headers are passed in
-  // then we get the right MIME type. When the in process plugin is removed we
-  // can fix the document loader properly and remove this hack.
-  if (!headers || strcmp(headers, "") == 0)
-    headers = "content-type: application/pdf";

[raymes, 2015/05/28 02:44:42]

Do we need to preserve this in document_loader?

[Lei Zhang, 2015/05/28 05:56:33]

See the code around document_loader.cc line 72.

-
   if (!original_url)
     return false;
 
   if (!stream_url)
     stream_url = original_url;
 
   // If we're in print preview mode we don't need to load the document yet.
   // A |kJSResetPrintPreviewModeType| message will be sent to the plugin letting
   // it know the url to load. By not loading here we avoid loading the same
   // document twice.
@@ skipping 55 matching lines @@
              dict.Get(pp::Var(kJSPrintPreviewGrayscale)).is_bool() &&
              dict.Get(pp::Var(kJSPrintPreviewPageCount)).is_int()) {
     url_ = dict.Get(pp::Var(kJSPrintPreviewUrl)).AsString();
     preview_pages_info_ = std::queue<PreviewPageInfo>();
     preview_document_load_state_ = LOAD_STATE_COMPLETE;
     document_load_state_ = LOAD_STATE_LOADING;
     LoadUrl(url_);
     preview_engine_.reset();
     engine_.reset(PDFEngine::Create(this));
     engine_->SetGrayscale(dict.Get(pp::Var(kJSPrintPreviewGrayscale)).AsBool());
-    engine_->New(url_.c_str());
+    engine_->New(url_.c_str(), nullptr /* empty header */);
 
     print_preview_page_count_ =
         std::max(dict.Get(pp::Var(kJSPrintPreviewPageCount)).AsInt(), 0);
 
     paint_manager_.InvalidateRect(pp::Rect(pp::Point(), plugin_size_));
   } else if (type == kJSLoadPreviewPageType &&
              dict.Get(pp::Var(kJSPreviewPageUrl)).is_string() &&
              dict.Get(pp::Var(kJSPreviewPageIndex)).is_int()) {
     ProcessPreviewPageInfo(dict.Get(pp::Var(kJSPreviewPageUrl)).AsString(),
                            dict.Get(pp::Var(kJSPreviewPageIndex)).AsInt());
@@ skipping 450 matching lines @@
 
   const PPB_CursorControl_Dev* cursor_interface =
       reinterpret_cast<const PPB_CursorControl_Dev*>(
       pp::Module::Get()->GetBrowserInterface(PPB_CURSOR_CONTROL_DEV_INTERFACE));
   if (!cursor_interface) {
     NOTREACHED();
     return;
   }
 
   cursor_interface->SetCursor(
-      pp_instance(), cursor_, pp::ImageData().pp_resource(), NULL);
+      pp_instance(), cursor_, pp::ImageData().pp_resource(), nullptr);
 }
 
 void OutOfProcessInstance::UpdateTickMarks(
     const std::vector<pp::Rect>& tickmarks) {
   float inverse_scale = 1.0f / device_scale_;
   std::vector<pp::Rect> scaled_tickmarks = tickmarks;
   for (size_t i = 0; i < scaled_tickmarks.size(); i++)
     ScaleRect(inverse_scale, &scaled_tickmarks[i]);
   tickmarks_ = scaled_tickmarks;
 }
@@ skipping 241 matching lines @@
       ExtractPrintPreviewPageIndex(preview_pages_info_.front().first);
   if (src_page_index > 0 &&  dest_page_index > -1 && preview_engine_.get())
     engine_->AppendPage(preview_engine_.get(), dest_page_index);
 
   preview_pages_info_.pop();
   // |print_preview_page_count_| is not updated yet. Do not load any
   // other preview pages till we get this information.
   if (print_preview_page_count_ == 0)
     return;
 
-  if (preview_pages_info_.size())
+  if (!preview_pages_info_.empty())
     LoadAvailablePreviewPage();
 }
 
 void OutOfProcessInstance::DocumentLoadFailed() {
   DCHECK(document_load_state_ == LOAD_STATE_LOADING);
   UserMetricsRecordAction("PDF.LoadFailure");
 
   if (did_call_start_loading_) {
     pp::PDF::DidStopLoading(this);
     did_call_start_loading_ = false;
@@ skipping 12 matching lines @@
 void OutOfProcessInstance::PreviewDocumentLoadFailed() {
   UserMetricsRecordAction("PDF.PreviewDocumentLoadFailure");
   if (preview_document_load_state_ != LOAD_STATE_LOADING ||
       preview_pages_info_.empty()) {
     return;
   }
 
   preview_document_load_state_ = LOAD_STATE_FAILED;
   preview_pages_info_.pop();
 
-  if (preview_pages_info_.size())
+  if (!preview_pages_info_.empty())
     LoadAvailablePreviewPage();
 }
 
 pp::Instance* OutOfProcessInstance::GetPluginInstance() {
   return this;
 }
 
 void OutOfProcessInstance::DocumentHasUnsupportedFeature(
     const std::string& feature) {
   std::string metric("PDF_Unsupported_");
@@ skipping 129 matching lines @@
   if (!rv.is_string())
     return std::string();
 
   return rv.AsString();
 }
 
 void OutOfProcessInstance::AppendBlankPrintPreviewPages() {
   if (print_preview_page_count_ == 0)
     return;
   engine_->AppendBlankPages(print_preview_page_count_);
-  if (preview_pages_info_.size() > 0)
+  if (!preview_pages_info_.empty())
     LoadAvailablePreviewPage();
 }
 
 bool OutOfProcessInstance::IsPrintPreview() {
   return IsPrintPreviewUrl(url_);
 }
 
 uint32 OutOfProcessInstance::GetBackgroundColor() {
   return background_color_;
 }
@@ skipping 12 matching lines @@
 
   int src_page_index = ExtractPrintPreviewPageIndex(url);
   if (src_page_index < 1)
     return;
 
   preview_pages_info_.push(std::make_pair(url, dst_page_index));
   LoadAvailablePreviewPage();
 }
 
 void OutOfProcessInstance::LoadAvailablePreviewPage() {
-  if (preview_pages_info_.size() <= 0 ||
+  if (preview_pages_info_.empty() ||
       document_load_state_ != LOAD_STATE_COMPLETE) {
     return;
   }
 
   std::string url = preview_pages_info_.front().first;
   int dst_page_index = preview_pages_info_.front().second;
   int src_page_index = ExtractPrintPreviewPageIndex(url);
   if (src_page_index < 1 ||
       dst_page_index >= print_preview_page_count_ ||
       preview_document_load_state_ == LOAD_STATE_LOADING) {
@@ skipping 13 matching lines @@
 pp::FloatPoint OutOfProcessInstance::BoundScrollOffsetToDocument(
     const pp::FloatPoint& scroll_offset) {
   float max_x = document_size_.width() * zoom_ - plugin_dip_size_.width();
   float x = std::max(std::min(scroll_offset.x(), max_x), 0.0f);
   float max_y = document_size_.height() * zoom_ - plugin_dip_size_.height();
   float y = std::max(std::min(scroll_offset.y(), max_y), 0.0f);
   return pp::FloatPoint(x, y);
 }
 
 }  // namespace chrome_pdf