Really Really fix tests broken at 9778206.
[pdfium.git] / testing / embedder_test.cpp
index e1473c0..1476522 100644 (file)
 #include <utility>
 #include <vector>
 
-#include "../core/include/fxcrt/fx_system.h"
 #include "../public/fpdf_text.h"
 #include "../public/fpdfview.h"
 #include "testing/gmock/include/gmock/gmock.h"
+#include "v8/include/libplatform/libplatform.h"
 #include "v8/include/v8.h"
 
 #ifdef _WIN32
@@ -36,24 +36,24 @@ static char* GetFileContents(const char* filename, size_t* retlen) {
   FILE* file = fopen(filename, "rb");
   if (!file) {
     fprintf(stderr, "Failed to open: %s\n", filename);
-    return NULL;
+    return nullptr;
   }
-  (void) fseek(file, 0, SEEK_END);
+  (void)fseek(file, 0, SEEK_END);
   size_t file_length = ftell(file);
   if (!file_length) {
-    return NULL;
+    return nullptr;
   }
-  (void) fseek(file, 0, SEEK_SET);
-  char* buffer = (char*) malloc(file_length);
+  (void)fseek(file, 0, SEEK_SET);
+  char* buffer = (char*)malloc(file_length);
   if (!buffer) {
-    return NULL;
+    return nullptr;
   }
   size_t bytes_read = fread(buffer, 1, file_length, file);
-  (void) fclose(file);
+  (void)fclose(file);
   if (bytes_read != file_length) {
     fprintf(stderr, "Failed to read: %s\n", filename);
     free(buffer);
-    return NULL;
+    return nullptr;
   }
   *retlen = bytes_read;
   return buffer;
@@ -67,7 +67,7 @@ static std::string GetFullPathForSnapshotFile(const std::string& exe_path,
   std::string result;
   if (!exe_path.empty()) {
     size_t last_separator = exe_path.rfind(PATH_SEPARATOR);
-    if (last_separator != std::string::npos)  {
+    if (last_separator != std::string::npos) {
       result = exe_path.substr(0, last_separator + 1);
     }
   }
@@ -94,58 +94,6 @@ static bool GetExternalData(const std::string& exe_path,
 
 }  // namespace
 
-class EmbedderTestDefaultDelegate : public EmbedderTest::Delegate {
- public:
-  int Alert(FPDF_WIDESTRING, FPDF_WIDESTRING, int, int) override {
-    printf("Form_Alert called.\n");
-    return 0;
-  }
-
-  void UnsupportedHandler(int type) {
-    std::string feature = "Unknown";
-    switch (type) {
-      case FPDF_UNSP_DOC_XFAFORM:
-        feature = "XFA";
-        break;
-      case FPDF_UNSP_DOC_PORTABLECOLLECTION:
-        feature = "Portfolios_Packages";
-        break;
-      case FPDF_UNSP_DOC_ATTACHMENT:
-      case FPDF_UNSP_ANNOT_ATTACHMENT:
-        feature = "Attachment";
-        break;
-      case FPDF_UNSP_DOC_SECURITY:
-        feature = "Rights_Management";
-        break;
-      case FPDF_UNSP_DOC_SHAREDREVIEW:
-        feature = "Shared_Review";
-        break;
-      case FPDF_UNSP_DOC_SHAREDFORM_ACROBAT:
-      case FPDF_UNSP_DOC_SHAREDFORM_FILESYSTEM:
-      case FPDF_UNSP_DOC_SHAREDFORM_EMAIL:
-        feature = "Shared_Form";
-        break;
-      case FPDF_UNSP_ANNOT_3DANNOT:
-        feature = "3D";
-        break;
-      case FPDF_UNSP_ANNOT_MOVIE:
-        feature = "Movie";
-        break;
-      case FPDF_UNSP_ANNOT_SOUND:
-        feature = "Sound";
-        break;
-      case FPDF_UNSP_ANNOT_SCREEN_MEDIA:
-      case FPDF_UNSP_ANNOT_SCREEN_RICHMEDIA:
-        feature = "Screen";
-        break;
-      case FPDF_UNSP_ANNOT_SIG:
-        feature = "Digital_Signature";
-        break;
-    }
-    printf("Unsupported feature: %s.\n", feature.c_str());
-  }
-};
-
 class TestLoader {
  public:
   TestLoader(const char* pBuf, size_t len);
@@ -155,26 +103,27 @@ class TestLoader {
 };
 
 TestLoader::TestLoader(const char* pBuf, size_t len)
-    : m_pBuf(pBuf), m_Len(len) {
-}
+    : m_pBuf(pBuf), m_Len(len) {}
 
-int Get_Block(void* param, unsigned long pos, unsigned char* pBuf,
+int Get_Block(void* param,
+              unsigned long pos,
+              unsigned char* pBuf,
               unsigned long size) {
-  TestLoader* pLoader = (TestLoader*) param;
-  if (pos + size < pos || pos + size > pLoader->m_Len) return 0;
+  TestLoader* pLoader = (TestLoader*)param;
+  if (pos + size < pos || pos + size > pLoader->m_Len)
+    return 0;
   memcpy(pBuf, pLoader->m_pBuf + pos, size);
   return 1;
 }
 
-bool Is_Data_Avail(FX_FILEAVAIL* pThis, size_t offset, size_t size) {
+FPDF_BOOL Is_Data_Avail(FX_FILEAVAIL* pThis, size_t offset, size_t size) {
   return true;
 }
 
-void Add_Segment(FX_DOWNLOADHINTS* pThis, size_t offset, size_t size) {
-}
+void Add_Segment(FX_DOWNLOADHINTS* pThis, size_t offset, size_t size) {}
 
-EmbedderTest::EmbedderTest() :
-      document_(nullptr),
+EmbedderTest::EmbedderTest()
+    : document_(nullptr),
       form_handle_(nullptr),
       avail_(nullptr),
       loader_(nullptr),
@@ -183,7 +132,7 @@ EmbedderTest::EmbedderTest() :
   memset(&hints_, 0, sizeof(hints_));
   memset(&file_access_, 0, sizeof(file_access_));
   memset(&file_avail_, 0, sizeof(file_avail_));
-  default_delegate_ = new EmbedderTestDefaultDelegate();
+  default_delegate_ = new EmbedderTest::Delegate();
   delegate_ = default_delegate_;
 }
 
@@ -192,40 +141,45 @@ EmbedderTest::~EmbedderTest() {
 }
 
 void EmbedderTest::SetUp() {
-    v8::V8::InitializeICU();
+  v8::V8::InitializeICU();
+
+  platform_ = v8::platform::CreateDefaultPlatform();
+  v8::V8::InitializePlatform(platform_);
+  v8::V8::Initialize();
+
+  // By enabling predictable mode, V8 won't post any background tasks.
+  const char predictable_flag[] = "--predictable";
+  v8::V8::SetFlagsFromString(predictable_flag,
+                             static_cast<int>(strlen(predictable_flag)));
 
 #ifdef V8_USE_EXTERNAL_STARTUP_DATA
-    ASSERT_TRUE(GetExternalData(g_exe_path_, "natives_blob.bin", &natives_));
-    ASSERT_TRUE(GetExternalData(g_exe_path_, "snapshot_blob.bin", &snapshot_));
-    v8::V8::SetNativesDataBlob(&natives_);
-    v8::V8::SetSnapshotDataBlob(&snapshot_);
+  ASSERT_TRUE(GetExternalData(g_exe_path_, "natives_blob.bin", &natives_));
+  ASSERT_TRUE(GetExternalData(g_exe_path_, "snapshot_blob.bin", &snapshot_));
+  v8::V8::SetNativesDataBlob(&natives_);
+  v8::V8::SetSnapshotDataBlob(&snapshot_);
 #endif  // V8_USE_EXTERNAL_STARTUP_DATA
 
-    FPDF_InitLibrary();
+  FPDF_InitLibrary();
 
-    UNSUPPORT_INFO* info = static_cast<UNSUPPORT_INFO*>(this);
-    memset(info, 0, sizeof(UNSUPPORT_INFO));
-    info->version = 1;
-    info->FSDK_UnSupport_Handler = UnsupportedHandlerTrampoline;
-    FSDK_SetUnSpObjProcessHandler(info);
-  }
+  UNSUPPORT_INFO* info = static_cast<UNSUPPORT_INFO*>(this);
+  memset(info, 0, sizeof(UNSUPPORT_INFO));
+  info->version = 1;
+  info->FSDK_UnSupport_Handler = UnsupportedHandlerTrampoline;
+  FSDK_SetUnSpObjProcessHandler(info);
+}
 
 void EmbedderTest::TearDown() {
-  if (form_handle_) {
+  if (document_) {
     FORM_DoDocumentAAction(form_handle_, FPDFDOC_AACTION_WC);
     FPDFDOC_ExitFormFillEnvironment(form_handle_);
-  }
-  if (document_) {
     FPDF_CloseDocument(document_);
   }
   FPDFAvail_Destroy(avail_);
   FPDF_DestroyLibrary();
-  if (loader_) {
-    delete loader_;
-  }
-  if (file_contents_) {
-    free(file_contents_);
-  }
+  v8::V8::ShutdownPlatform();
+  delete platform_;
+  delete loader_;
+  free(file_contents_);
 }
 
 bool EmbedderTest::OpenDocument(const std::string& filename) {
@@ -246,25 +200,27 @@ bool EmbedderTest::OpenDocument(const std::string& filename) {
   hints_.AddSegment = Add_Segment;
 
   avail_ = FPDFAvail_Create(&file_avail_, &file_access_);
-  (void) FPDFAvail_IsDocAvail(avail_, &hints_);
+  (void)FPDFAvail_IsDocAvail(avail_, &hints_);
 
   if (!FPDFAvail_IsLinearized(avail_)) {
-    document_ = FPDF_LoadCustomDocument(&file_access_, NULL);
+    document_ = FPDF_LoadCustomDocument(&file_access_, nullptr);
   } else {
-    document_ = FPDFAvail_GetDocument(avail_, NULL);
+    document_ = FPDFAvail_GetDocument(avail_, nullptr);
   }
 
-  (void) FPDF_GetDocPermissions(document_);
-  (void) FPDFAvail_IsFormAvail(avail_, &hints_);
+  (void)FPDF_GetDocPermissions(document_);
+  (void)FPDFAvail_IsFormAvail(avail_, &hints_);
 
   IPDF_JSPLATFORM* platform = static_cast<IPDF_JSPLATFORM*>(this);
   memset(platform, 0, sizeof(IPDF_JSPLATFORM));
-  platform->version = 1;
+  platform->version = 2;
   platform->app_alert = AlertTrampoline;
 
   FPDF_FORMFILLINFO* formfillinfo = static_cast<FPDF_FORMFILLINFO*>(this);
   memset(formfillinfo, 0, sizeof(FPDF_FORMFILLINFO));
   formfillinfo->version = 1;
+  formfillinfo->FFI_SetTimer = SetTimerTrampoline;
+  formfillinfo->FFI_KillTimer = KillTimerTrampoline;
   formfillinfo->m_pJsPlatform = platform;
 
   form_handle_ = FPDFDOC_InitFormFillEnvironment(document_, formfillinfo);
@@ -281,14 +237,14 @@ void EmbedderTest::DoOpenActions() {
 
 int EmbedderTest::GetFirstPageNum() {
   int first_page = FPDFAvail_GetFirstPageNum(document_);
-  (void) FPDFAvail_IsPageAvail(avail_, first_page, &hints_);
+  (void)FPDFAvail_IsPageAvail(avail_, first_page, &hints_);
   return first_page;
 }
 
 int EmbedderTest::GetPageCount() {
   int page_count = FPDF_GetPageCount(document_);
   for (int i = 0; i < page_count; ++i) {
-    (void) FPDFAvail_IsPageAvail(avail_, i, &hints_);
+    (void)FPDFAvail_IsPageAvail(avail_, i, &hints_);
   }
   return page_count;
 }
@@ -336,6 +292,20 @@ int EmbedderTest::AlertTrampoline(IPDF_JSPLATFORM* platform,
   return test->delegate_->Alert(message, title, type, icon);
 }
 
+// static
+int EmbedderTest::SetTimerTrampoline(FPDF_FORMFILLINFO* info,
+                                     int msecs,
+                                     TimerCallback fn) {
+  EmbedderTest* test = static_cast<EmbedderTest*>(info);
+  return test->delegate_->SetTimer(msecs, fn);
+}
+
+// static
+void EmbedderTest::KillTimerTrampoline(FPDF_FORMFILLINFO* info, int id) {
+  EmbedderTest* test = static_cast<EmbedderTest*>(info);
+  return test->delegate_->KillTimer(id);
+}
+
 // Can't use gtest-provided main since we need to stash the path to the
 // executable in order to find the external V8 binary data files.
 int main(int argc, char** argv) {