// See bug 465.
TEST_F(FPDFViewEmbeddertest, EmptyDocument) {
EXPECT_TRUE(CreateEmptyDocument());
{
int version = 42;
EXPECT_FALSE(FPDF_GetFileVersion(document(), &version));
EXPECT_EQ(0, version);
}
{
#ifndef PDF_ENABLE_XFA
const unsigned long kExpected = 0;
#else
const unsigned long kExpected = static_cast<uint32_t>(-1);
#endif
EXPECT_EQ(kExpected, FPDF_GetDocPermissions(document()));
}
EXPECT_EQ(-1, FPDF_GetSecurityHandlerRevision(document()));
EXPECT_EQ(0, FPDF_GetPageCount(document()));
EXPECT_TRUE(FPDF_VIEWERREF_GetPrintScaling(document()));
EXPECT_EQ(1, FPDF_VIEWERREF_GetNumCopies(document()));
EXPECT_EQ(DuplexUndefined, FPDF_VIEWERREF_GetDuplex(document()));
char buf[100];
EXPECT_EQ(0U, FPDF_VIEWERREF_GetName(document(), "foo", nullptr, 0));
EXPECT_EQ(0U, FPDF_VIEWERREF_GetName(document(), "foo", buf, sizeof(buf)));
EXPECT_EQ(0u, FPDF_CountNamedDests(document()));
}
TEST_F(FPDFViewEmbeddertest, Document) {
EXPECT_TRUE(OpenDocument("about_blank.pdf"));
EXPECT_EQ(1, GetPageCount());
EXPECT_EQ(0, GetFirstPageNum());
int version;
EXPECT_TRUE(FPDF_GetFileVersion(document(), &version));
EXPECT_EQ(14, version);
EXPECT_EQ(0xFFFFFFFF, FPDF_GetDocPermissions(document()));
EXPECT_EQ(-1, FPDF_GetSecurityHandlerRevision(document()));
}
TEST_F(CPDFSecurityHandlerEmbedderTest, PasswordAfterGenerateSave) {
#if _FX_PLATFORM_ == _FX_PLATFORM_LINUX_
const char md5[] = "7048dca58e2ed8f93339008b91e4eb4e";
#elif _FX_PLATFORM_ == _FX_PLATFORM_APPLE_
const char md5[] = "6951b6c9891dfe0332a5b1983e484400";
#else
const char md5[] = "041c2fb541c8907cc22ce101b686c79e";
#endif // _FX_PLATFORM_ == _FX_PLATFORM_LINUX_
{
ASSERT_TRUE(OpenDocumentWithOptions("encrypted.pdf", "5678",
LinearizeOption::kMustLinearize,
JavaScriptOption::kEnableJavaScript));
FPDF_PAGE page = LoadPage(0);
ASSERT_TRUE(page);
FPDF_PAGEOBJECT red_rect = FPDFPageObj_CreateNewRect(10, 10, 20, 20);
ASSERT_TRUE(red_rect);
EXPECT_TRUE(FPDFPath_SetFillColor(red_rect, 255, 0, 0, 255));
EXPECT_TRUE(FPDFPath_SetDrawMode(red_rect, FPDF_FILLMODE_ALTERNATE, 0));
FPDFPage_InsertObject(page, red_rect);
ScopedFPDFBitmap bitmap = RenderLoadedPage(page);
CompareBitmap(bitmap.get(), 612, 792, md5);
EXPECT_TRUE(FPDFPage_GenerateContent(page));
SetWholeFileAvailable();
EXPECT_TRUE(FPDF_SaveAsCopy(document(), this, 0));
UnloadPage(page);
}
std::string new_file = GetString();
FPDF_FILEACCESS file_access;
memset(&file_access, 0, sizeof(file_access));
file_access.m_FileLen = new_file.size();
file_access.m_GetBlock = GetBlockFromString;
file_access.m_Param = &new_file;
EXPECT_FALSE(FPDF_LoadCustomDocument(&file_access, nullptr));
struct {
const char* password;
const unsigned long permissions;
} tests[] = {{"1234", 0xFFFFF2C0}, {"5678", 0xFFFFFFFC}};
for (const auto& test : tests) {
OpenSavedDocument(test.password);
FPDF_PAGE page = LoadSavedPage(0);
VerifySavedRendering(page, 612, 792, md5);
EXPECT_EQ(test.permissions, FPDF_GetDocPermissions(saved_document_));
CloseSavedPage(page);
CloseSavedDocument();
}
}
bool EmbedderTest::OpenDocument(const std::string& filename) {
file_contents_ = GetFileContents(filename.c_str(), &file_length_);
if (!file_contents_) {
return false;
}
loader_ = new TestLoader(file_contents_, file_length_);
file_access_.m_FileLen = static_cast<unsigned long>(file_length_);
file_access_.m_GetBlock = Get_Block;
file_access_.m_Param = loader_;
file_avail_.version = 1;
file_avail_.IsDataAvail = Is_Data_Avail;
hints_.version = 1;
hints_.AddSegment = Add_Segment;
avail_ = FPDFAvail_Create(&file_avail_, &file_access_);
(void)FPDFAvail_IsDocAvail(avail_, &hints_);
if (!FPDFAvail_IsLinearized(avail_)) {
document_ = FPDF_LoadCustomDocument(&file_access_, nullptr);
} else {
document_ = FPDFAvail_GetDocument(avail_, nullptr);
}
(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 = 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->FFI_GetPage = GetPageTrampoline;
formfillinfo->m_pJsPlatform = platform;
form_handle_ = FPDFDOC_InitFormFillEnvironment(document_, formfillinfo);
FPDF_SetFormFieldHighlightColor(form_handle_, 0, 0xFFE4DD);
FPDF_SetFormFieldHighlightAlpha(form_handle_, 100);
return true;
}
bool EmbedderTest::OpenDocument(const std::string& filename) {
file_contents_ = GetFileContents(filename.c_str(), &file_length_);
if (!file_contents_) {
return false;
}
loader_ = new TestLoader(file_contents_, file_length_);
file_access_.m_FileLen = static_cast<unsigned long>(file_length_);
file_access_.m_GetBlock = Get_Block;
file_access_.m_Param = loader_;
file_avail_.version = 1;
file_avail_.IsDataAvail = Is_Data_Avail;
hints_.version = 1;
hints_.AddSegment = Add_Segment;
avail_ = FPDFAvail_Create(&file_avail_, &file_access_);
(void) FPDFAvail_IsDocAvail(avail_, &hints_);
if (!FPDFAvail_IsLinearized(avail_)) {
document_ = FPDF_LoadCustomDocument(&file_access_, NULL);
} else {
document_ = FPDFAvail_GetDocument(avail_, NULL);
}
(void) FPDF_GetDocPermissions(document_);
(void) FPDFAvail_IsFormAvail(avail_, &hints_);
IPDF_JSPLATFORM platform_callbacks;
memset(&platform_callbacks, '\0', sizeof(platform_callbacks));
platform_callbacks.version = 1;
platform_callbacks.app_alert = Form_Alert;
FPDF_FORMFILLINFO form_callbacks;
memset(&form_callbacks, '\0', sizeof(form_callbacks));
form_callbacks.version = 1;
form_callbacks.m_pJsPlatform = &platform_callbacks;
form_handle_ = FPDFDOC_InitFormFillEnvironment(document_, &form_callbacks);
FPDF_SetFormFieldHighlightColor(form_handle_, 0, 0xFFE4DD);
FPDF_SetFormFieldHighlightAlpha(form_handle_, 100);
return true;
}
TEST_F(CPDFSecurityHandlerEmbedderTest, OwnerPassword) {
ASSERT_TRUE(OpenDocumentWithPassword("encrypted.pdf", "5678"));
EXPECT_EQ(0xFFFFFFFC, FPDF_GetDocPermissions(document()));
}
TEST_F(CPDFSecurityHandlerEmbedderTest, UnencryptedWithPassword) {
ASSERT_TRUE(OpenDocumentWithPassword("about_blank.pdf", "foobar"));
EXPECT_EQ(0xFFFFFFFF, FPDF_GetDocPermissions(document()));
}
TEST_F(CPDFSecurityHandlerEmbedderTest, UserPasswordVersion5) {
ASSERT_TRUE(OpenDocumentWithPassword("bug_644.pdf", "b"));
EXPECT_EQ(0xFFFFFFFC, FPDF_GetDocPermissions(document()));
}
TEST_F(CPDFSecurityHandlerEmbeddertest, Unencrypted) {
ASSERT_TRUE(OpenDocument("about_blank.pdf"));
EXPECT_EQ(0xFFFFFFFF, FPDF_GetDocPermissions(document()));
}
TEST_F(CPDFSecurityHandlerEmbeddertest, UserPassword) {
ASSERT_TRUE(OpenDocument("encrypted.pdf", "1234"));
EXPECT_EQ(0xFFFFF2C0, FPDF_GetDocPermissions(document()));
}
bool EmbedderTest::OpenDocument(const std::string& filename,
const char* password,
bool must_linearize) {
std::string file_path;
if (!PathService::GetTestFilePath(filename, &file_path))
return false;
file_contents_ = GetFileContents(file_path.c_str(), &file_length_);
if (!file_contents_)
return false;
EXPECT_TRUE(!loader_);
loader_ = new TestLoader(file_contents_.get(), file_length_);
file_access_.m_FileLen = static_cast<unsigned long>(file_length_);
file_access_.m_GetBlock = TestLoader::GetBlock;
file_access_.m_Param = loader_;
file_avail_.version = 1;
file_avail_.IsDataAvail = Is_Data_Avail;
hints_.version = 1;
hints_.AddSegment = Add_Segment;
avail_ = FPDFAvail_Create(&file_avail_, &file_access_);
if (FPDFAvail_IsLinearized(avail_) == PDF_LINEARIZED) {
document_ = FPDFAvail_GetDocument(avail_, password);
if (!document_) {
return false;
}
int32_t nRet = PDF_DATA_NOTAVAIL;
while (nRet == PDF_DATA_NOTAVAIL) {
nRet = FPDFAvail_IsDocAvail(avail_, &hints_);
}
if (nRet == PDF_DATA_ERROR) {
return false;
}
nRet = FPDFAvail_IsFormAvail(avail_, &hints_);
if (nRet == PDF_FORM_ERROR || nRet == PDF_FORM_NOTAVAIL) {
return false;
}
int page_count = FPDF_GetPageCount(document_);
for (int i = 0; i < page_count; ++i) {
nRet = PDF_DATA_NOTAVAIL;
while (nRet == PDF_DATA_NOTAVAIL) {
nRet = FPDFAvail_IsPageAvail(avail_, i, &hints_);
}
if (nRet == PDF_DATA_ERROR) {
return false;
}
}
} else {
if (must_linearize) {
return false;
}
document_ = FPDF_LoadCustomDocument(&file_access_, nullptr);
if (!document_) {
return false;
}
}
#ifdef PDF_ENABLE_XFA
int docType = DOCTYPE_PDF;
if (FPDF_HasXFAField(document_, &docType)) {
if (docType != DOCTYPE_PDF)
(void)FPDF_LoadXFA(document_);
}
#endif // PDF_ENABLE_XFA
(void)FPDF_GetDocPermissions(document_);
SetupFormFillEnvironment();
return true;
}
