Add a WideStringToString() helper function to PDFiumEngine.

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 576 matching lines @@
       FPDF_GetMetaText(doc, key.c_str(), string_adapter.GetData(), size));
   return base::UTF16ToUTF8(value);
 }
 
 gin::IsolateHolder* g_isolate_holder = nullptr;
 
 void SetUpV8() {
   gin::IsolateHolder::Initialize(gin::IsolateHolder::kNonStrictMode,
                                  gin::IsolateHolder::kStableV8Extras,
                                  gin::ArrayBufferAllocator::SharedInstance());
+  DCHECK(!g_isolate_holder);
   g_isolate_holder = new gin::IsolateHolder(base::ThreadTaskRunnerHandle::Get(),
                                             gin::IsolateHolder::kSingleThread);
   g_isolate_holder->isolate()->Enter();
 }
 
 void TearDownV8() {
   g_isolate_holder->isolate()->Exit();
   delete g_isolate_holder;
   g_isolate_holder = nullptr;
 }
 
 int GetBlockForJpeg(void* param,
                     unsigned long pos,
                     unsigned char* buf,
                     unsigned long size) {
   std::vector<uint8_t>* data_vector = static_cast<std::vector<uint8_t>*>(param);
   if (pos + size < pos || pos + size > data_vector->size())
     return 0;
   memcpy(buf, data_vector->data() + pos, size);
   return 1;
 }
 
+std::string WideStringToString(FPDF_WIDESTRING wide_string) {
+  return base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(wide_string));
+}
+
 }  // namespace
 
 bool InitializeSDK() {
   SetUpV8();
 
   FPDF_LIBRARY_CONFIG config;
   config.version = 2;
   config.m_pUserFontPaths = nullptr;
   config.m_pIsolate = v8::Isolate::GetCurrent();
   config.m_v8EmbedderSlot = gin::kEmbedderPDFium;
@@ skipping 159 matching lines @@
 
 #if defined(PDF_ENABLE_XFA)
 
 void PDFiumEngine::Form_EmailTo(FPDF_FORMFILLINFO* param,
                                 FPDF_FILEHANDLER* file_handler,
                                 FPDF_WIDESTRING to,
                                 FPDF_WIDESTRING subject,
                                 FPDF_WIDESTRING cc,
                                 FPDF_WIDESTRING bcc,
                                 FPDF_WIDESTRING message) {
-  std::string to_str =
-      base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(to));
-  std::string subject_str =
-      base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(subject));
-  std::string cc_str =
-      base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(cc));
-  std::string bcc_str =
-      base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(bcc));
-  std::string message_str =
-      base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(message));
+  std::string to_str = WideStringToString(to);
+  std::string subject_str = WideStringToString(subject);
+  std::string cc_str = WideStringToString(cc);
+  std::string bcc_str = WideStringToString(bcc);
+  std::string message_str = WideStringToString(message);
 
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
   engine->client_->Email(to_str, cc_str, bcc_str, subject_str, message_str);
 }
 
 void PDFiumEngine::Form_DisplayCaret(FPDF_FORMFILLINFO* param,
                                      FPDF_PAGE page,
                                      FPDF_BOOL visible,
                                      double left,
                                      double top,
@@ skipping 67 matching lines @@
   return false;
 }
 
 FPDF_BOOL PDFiumEngine::Form_PostRequestURL(FPDF_FORMFILLINFO* param,
                                             FPDF_WIDESTRING url,
                                             FPDF_WIDESTRING data,
                                             FPDF_WIDESTRING content_type,
                                             FPDF_WIDESTRING encode,
                                             FPDF_WIDESTRING header,
                                             FPDF_BSTR* response) {
-  std::string url_str =
-      base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(url));
-  std::string data_str =
-      base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(data));
-  std::string content_type_str =
-      base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(content_type));
-  std::string encode_str =
-      base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(encode));
-  std::string header_str =
-      base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(header));
+  std::string url_str = WideStringToString(url);
+  std::string data_str = WideStringToString(data);
+  std::string content_type_str = WideStringToString(content_type);
+  std::string encode_str = WideStringToString(encode);
+  std::string header_str = WideStringToString(header);
 
   std::string javascript = "alert(\"Post:" + url_str + "," + data_str + "," +
                            content_type_str + "," + encode_str + "," +
                            header_str + "\")";
   return true;
 }
 
 FPDF_BOOL PDFiumEngine::Form_PutRequestURL(FPDF_FORMFILLINFO* param,
                                            FPDF_WIDESTRING url,
                                            FPDF_WIDESTRING data,
                                            FPDF_WIDESTRING encode) {
-  std::string url_str =
-      base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(url));
-  std::string data_str =
-      base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(data));
-  std::string encode_str =
-      base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(encode));
+  std::string url_str = WideStringToString(url);
+  std::string data_str = WideStringToString(data);
+  std::string encode_str = WideStringToString(encode);
 
   std::string javascript =
       "alert(\"Put:" + url_str + "," + data_str + "," + encode_str + "\")";
 
   return true;
 }
 
 void PDFiumEngine::Form_UploadTo(FPDF_FORMFILLINFO* param,
                                  FPDF_FILEHANDLER* file_handle,
                                  int file_flag,
                                  FPDF_WIDESTRING to) {
-  std::string to_str =
-      base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(to));
+  std::string to_str = WideStringToString(to);
   // TODO: needs the full implementation of form uploading
 }
 
 FPDF_LPFILEHANDLER PDFiumEngine::Form_DownloadFromURL(FPDF_FORMFILLINFO* param,
                                                       FPDF_WIDESTRING url) {
   // NOTE: Think hard about the security implications before allowing
   // a PDF file to perform this action.
   return nullptr;
 }
 
 FPDF_FILEHANDLER* PDFiumEngine::Form_OpenFile(FPDF_FORMFILLINFO* param,
                                               int file_flag,
                                               FPDF_WIDESTRING url,
                                               const char* mode) {
   // NOTE: Think hard about the security implications before allowing
   // a PDF file to perform this action.
   return nullptr;
 }
 
 void PDFiumEngine::Form_GotoURL(FPDF_FORMFILLINFO* param,
                                 FPDF_DOCUMENT document,
                                 FPDF_WIDESTRING url) {
-  std::string url_str =
-      base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(url));
+  std::string url_str = WideStringToString(url);
   // TODO: needs to implement GOTO URL action
 }
 
 int PDFiumEngine::Form_GetLanguage(FPDF_FORMFILLINFO* param,
                                    void* language,
                                    int length) {
   return 0;
 }
 
 #endif  // defined(PDF_ENABLE_XFA)
@@ skipping 391 matching lines @@
 }
 
 pp::Resource PDFiumEngine::PrintPages(
     const PP_PrintPageNumberRange_Dev* page_ranges,
     uint32_t page_range_count,
     const PP_PrintSettings_Dev& print_settings) {
   ScopedSubstFont scoped_subst_font(this);
   if (HasPermission(PDFEngine::PERMISSION_PRINT_HIGH_QUALITY) &&
       (print_settings.format & PP_PRINTOUTPUTFORMAT_PDF)) {
     return PrintPagesAsPDF(page_ranges, page_range_count, print_settings);
-  } else if (HasPermission(PDFEngine::PERMISSION_PRINT_LOW_QUALITY)) {
+  }
+  if (HasPermission(PDFEngine::PERMISSION_PRINT_LOW_QUALITY))
     return PrintPagesAsRasterPDF(page_ranges, page_range_count, print_settings);
-  }
-
   return pp::Resource();
 }
 
 FPDF_DOCUMENT PDFiumEngine::CreateSinglePageRasterPdf(
     double source_page_width,
     double source_page_height,
     const PP_PrintSettings_Dev& print_settings,
     PDFiumPage* page_to_print) {
   FPDF_DOCUMENT temp_doc = FPDF_CreateNewDocument();
   if (!temp_doc)
@@ skipping 814 matching lines @@
 
   // Move back/forward through the search locations we previously found.
   size_t new_index;
   const size_t last_index = find_results_.size() - 1;
 
   if (resume_find_index_.valid()) {
     new_index = resume_find_index_.GetIndex();
     resume_find_index_.Invalidate();
   } else if (current_find_index_.valid()) {
     size_t current_index = current_find_index_.GetIndex();
-    if (forward) {
-      if (current_index >= last_index) {
-        current_find_index_.Invalidate();
-        client_->NotifySelectedFindResultChanged(-1);
-        client_->NotifyNumberOfFindResultsChanged(find_results_.size(), true);
-        return true;
-      }
-      new_index = current_index + 1;
-    } else {
-      if (current_find_index_.GetIndex() == 0) {
-        current_find_index_.Invalidate();
-        client_->NotifySelectedFindResultChanged(-1);
-        client_->NotifyNumberOfFindResultsChanged(find_results_.size(), true);
-        return true;
-      }
-      new_index = current_index - 1;
+    if ((forward && current_index >= last_index) ||
+        (!forward && current_index == 0)) {
+      current_find_index_.Invalidate();
+      client_->NotifySelectedFindResultChanged(-1);
+      client_->NotifyNumberOfFindResultsChanged(find_results_.size(), true);
+      return true;
     }
+    int increment = forward ? 1 : -1;
+    new_index = current_index + increment;
   } else {
     new_index = forward ? 0 : last_index;
   }
   current_find_index_.SetIndex(new_index);
 
   // Update the selection before telling the client to scroll, since it could
   // paint then.
   selection_.clear();
   selection_.push_back(find_results_[current_find_index_.GetIndex()]);
 
@@ skipping 1488 matching lines @@
   };
 
   enum AlertResult {
     ALERT_RESULT_OK = 1,
     ALERT_RESULT_CANCEL,
     ALERT_RESULT_NO,
     ALERT_RESULT_YES
   };
 
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
-  std::string message_str =
-      base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(message));
+  std::string message_str = WideStringToString(message);
   if (type == ALERT_TYPE_OK) {
     engine->client_->Alert(message_str);
     return ALERT_RESULT_OK;
   }
 
   bool rv = engine->client_->Confirm(message_str);
   if (type == ALERT_TYPE_OK_CANCEL)
     return rv ? ALERT_RESULT_OK : ALERT_RESULT_CANCEL;
   return rv ? ALERT_RESULT_YES : ALERT_RESULT_NO;
 }
 
 void PDFiumEngine::Form_Beep(IPDF_JSPLATFORM* param, int type) {
   // Beeps are annoying, and not possible using javascript, so ignore for now.
 }
 
 int PDFiumEngine::Form_Response(IPDF_JSPLATFORM* param,
                                 FPDF_WIDESTRING question,
                                 FPDF_WIDESTRING title,
                                 FPDF_WIDESTRING default_response,
                                 FPDF_WIDESTRING label,
                                 FPDF_BOOL password,
                                 void* response,
                                 int length) {
-  std::string question_str =
-      base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(question));
-  std::string default_str = base::UTF16ToUTF8(
-      reinterpret_cast<const base::char16*>(default_response));
+  std::string question_str = WideStringToString(question);
+  std::string default_str = WideStringToString(default_response);
 
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
   std::string rv = engine->client_->Prompt(question_str, default_str);
   base::string16 rv_16 = base::UTF8ToUTF16(rv);
   int rv_bytes = rv_16.size() * sizeof(base::char16);
   if (response) {
     int bytes_to_copy = rv_bytes < length ? rv_bytes : length;
     memcpy(response, rv_16.c_str(), bytes_to_copy);
   }
   return rv_bytes;
@@ skipping 13 matching lines @@
                              void* mail_data,
                              int length,
                              FPDF_BOOL ui,
                              FPDF_WIDESTRING to,
                              FPDF_WIDESTRING subject,
                              FPDF_WIDESTRING cc,
                              FPDF_WIDESTRING bcc,
                              FPDF_WIDESTRING message) {
   // Note: |mail_data| and |length| are ignored. We don't handle attachments;
   // there is no way with mailto.
-  std::string to_str =
-      base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(to));
-  std::string cc_str =
-      base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(cc));
-  std::string bcc_str =
-      base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(bcc));
-  std::string subject_str =
-      base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(subject));
-  std::string message_str =
-      base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(message));
+  std::string to_str = WideStringToString(to);
+  std::string cc_str = WideStringToString(cc);
+  std::string bcc_str = WideStringToString(bcc);
+  std::string subject_str = WideStringToString(subject);
+  std::string message_str = WideStringToString(message);
 
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
   engine->client_->Email(to_str, cc_str, bcc_str, subject_str, message_str);
 }
 
 void PDFiumEngine::Form_Print(IPDF_JSPLATFORM* param,
                               FPDF_BOOL ui,
                               int start,
                               int end,
                               FPDF_BOOL silent,
                               FPDF_BOOL shrink_to_fit,
                               FPDF_BOOL print_as_image,
                               FPDF_BOOL reverse,
                               FPDF_BOOL annotations) {
   // No way to pass the extra information to the print dialog using JavaScript.
   // Just opening it is fine for now.
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
   engine->client_->Print();
 }
 
 void PDFiumEngine::Form_SubmitForm(IPDF_JSPLATFORM* param,
                                    void* form_data,
                                    int length,
                                    FPDF_WIDESTRING url) {
-  std::string url_str =
-      base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(url));
+  std::string url_str = WideStringToString(url);
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
   engine->client_->SubmitForm(url_str, form_data, length);
 }
 
 void PDFiumEngine::Form_GotoPage(IPDF_JSPLATFORM* param, int page_number) {
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
   engine->ScrollToPage(page_number);
 }
 
 int PDFiumEngine::Form_Browse(IPDF_JSPLATFORM* param,
@@ skipping 278 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