PDF: Use an empty password as a sentinel value for no password.

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 <stddef.h>
 #include <stdint.h>
 
@@ skipping 2385 matching lines @@
     return;
   }
 
   // If we're in the middle of getting a password, just return. We will retry
   // loading the document after we get the password anyway.
   if (getting_password_)
     return;
 
   ScopedUnsupportedFeature scoped_unsupported_feature(this);
   bool needs_password = false;
-  if (TryLoadingDoc(false, std::string(), &needs_password)) {
-    ContinueLoadingDocument(false, std::string());
+  if (TryLoadingDoc(std::string(), &needs_password)) {
+    ContinueLoadingDocument(std::string());
     return;
   }
   if (needs_password)
     GetPasswordAndLoad();
   else
     client_->DocumentLoadFailed();
 }
 
-bool PDFiumEngine::TryLoadingDoc(bool with_password,
-                                 const std::string& password,
+bool PDFiumEngine::TryLoadingDoc(const std::string& password,
                                  bool* needs_password) {
   *needs_password = false;
   if (doc_)
     return true;
 
   const char* password_cstr = nullptr;
-  if (with_password) {
+  if (!password.empty()) {
     password_cstr = password.c_str();
     password_tries_remaining_--;
   }
   if (doc_loader_.IsDocumentComplete() &&
       !FPDFAvail_IsLinearized(fpdf_availability_)) {
     doc_ = FPDF_LoadCustomDocument(&file_access_, password_cstr);
   } else {
     doc_ = FPDFAvail_GetDocument(fpdf_availability_, password_cstr);
   }
 
   if (!doc_ && FPDF_GetLastError() == FPDF_ERR_PASSWORD)
     *needs_password = true;
 
   return !!doc_;
 }
 
 void PDFiumEngine::GetPasswordAndLoad() {
   getting_password_ = true;
   DCHECK(!doc_ && FPDF_GetLastError() == FPDF_ERR_PASSWORD);
   client_->GetDocumentPassword(password_factory_.NewCallbackWithOutput(
       &PDFiumEngine::OnGetPasswordComplete));
 }
 
 void PDFiumEngine::OnGetPasswordComplete(int32_t result,
                                          const pp::Var& password) {
   getting_password_ = false;
 
-  bool password_given = false;
   std::string password_text;
-  if (result == PP_OK && password.is_string()) {
+  if (result == PP_OK && password.is_string())
     password_text = password.AsString();
-    if (!password_text.empty())
-      password_given = true;
-  }
-  ContinueLoadingDocument(password_given, password_text);
+  ContinueLoadingDocument(password_text);
 }
 
-void PDFiumEngine::ContinueLoadingDocument(
-    bool has_password,
-    const std::string& password) {
+void PDFiumEngine::ContinueLoadingDocument(const std::string& password) {
   ScopedUnsupportedFeature scoped_unsupported_feature(this);
 
   bool needs_password = false;
-  bool loaded = TryLoadingDoc(has_password, password, &needs_password);
-  bool password_incorrect = !loaded && has_password && needs_password;
+  bool loaded = TryLoadingDoc(password, &needs_password);
+  bool password_incorrect = !loaded && needs_password && !password.empty();
   if (password_incorrect && password_tries_remaining_ > 0) {
     GetPasswordAndLoad();
     return;
   }
 
   if (!doc_) {
     client_->DocumentLoadFailed();
     return;
   }
 
@@ skipping 1397 matching lines @@
   FPDF_DOCUMENT doc =
       FPDF_LoadMemDocument(pdf_buffer, pdf_buffer_size, nullptr);
   if (!doc)
     return false;
   bool success = FPDF_GetPageSizeByIndex(doc, page_number, width, height) != 0;
   FPDF_CloseDocument(doc);
   return success;
 }
 
 }  // namespace chrome_pdf