Fix UAF in chrome_pdf::Instance::GetURL()

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 "base/json/json_writer.h"
 #include "base/logging.h"
@@ skipping 593 matching lines @@
       FORM_DoDocumentAAction(form_, FPDFDOC_AACTION_WC);
       FPDFDOC_ExitFormFillEnviroument(form_);
     }
     FPDF_CloseDocument(doc_);
   }
 
   if (fpdf_availability_)
     FPDFAvail_Destroy(fpdf_availability_);
 }
 
+void PDFiumEngine::ClientDestroyed() {
+  client_ = NULL;
+}
+
 int PDFiumEngine::GetBlock(void* param, unsigned long position,
                            unsigned char* buffer, unsigned long size) {
   DocumentLoader* loader = static_cast<DocumentLoader*>(param);
   return loader->GetBlock(position, size, buffer);
 }
 
 bool PDFiumEngine::IsDataAvail(FX_FILEAVAIL* param,
                                size_t offset, size_t size) {
   PDFiumEngine::FileAvail* file_avail =
       static_cast<PDFiumEngine::FileAvail*>(param);
@@ skipping 29 matching lines @@
 
 void PDFiumEngine::PluginSizeUpdated(const pp::Size& size) {
   CancelPaints();
 
   plugin_size_ = size;
   CalculateVisiblePages();
 }
 
 void PDFiumEngine::ScrolledToXPosition(int position) {
   CancelPaints();
+  if (!client_)
+    return;
 
   int old_x = position_.x();
   position_.set_x(position);
   CalculateVisiblePages();
   client_->Scroll(pp::Point(old_x - position, 0));
 }
 
 void PDFiumEngine::ScrolledToYPosition(int position) {
   CancelPaints();
+  if (!client_)
+    return;
 
   int old_y = position_.y();
   position_.set_y(position);
   CalculateVisiblePages();
   client_->Scroll(pp::Point(0, old_y - position));
 }
 
 void PDFiumEngine::PrePaint() {
   for (size_t i = 0; i < progressive_paints_.size(); ++i)
     progressive_paints_[i].painted_ = false;
@@ skipping 68 matching lines @@
     --i;
   }
 }
 
 bool PDFiumEngine::HandleDocumentLoad(const pp::URLLoader& loader) {
   password_tries_remaining_ = kMaxPasswordTries;
   return doc_loader_.Init(loader, url_, headers_);
 }
 
 pp::Instance* PDFiumEngine::GetPluginInstance() {
-  return client_->GetPluginInstance();
+  return client_ ? client_->GetPluginInstance() : NULL;
 }
 
 pp::URLLoader PDFiumEngine::CreateURLLoader() {
-  return client_->CreateURLLoader();
+  return client_ ? client_->CreateURLLoader() : pp::URLLoader();
 }
 
 void PDFiumEngine::AppendPage(PDFEngine* engine, int index) {
   // Unload and delete the blank page before appending.
   pages_[index]->Unload();
   pages_[index]->set_calculated_links(false);
   pp::Size curr_page_size = GetPageSize(index);
   FPDFPage_Delete(doc_, index);
   FPDF_ImportPages(doc_,
                    static_cast<PDFiumEngine*>(engine)->doc(),
                    "1",
                    index);
   pp::Size new_page_size = GetPageSize(index);
   if (curr_page_size != new_page_size)
     LoadPageInfo(true);
+  if (!client_)
+    return;
+
   client_->Invalidate(GetPageScreenRect(index));
 }
 
 pp::Point PDFiumEngine::GetScrollPosition() {
   return position_;
 }
 
 void PDFiumEngine::SetScrollPosition(const pp::Point& position) {
   position_ = position;
 }
@@ skipping 24 matching lines @@
     return;
   }
 
   // LoadDocument() will result in |pending_pages_| being reset so there's no
   // need to run the code below in that case.
   bool update_pages = false;
   std::vector<int> still_pending;
   for (size_t i = 0; i < pending_pages_.size(); ++i) {
     if (CheckPageAvailable(pending_pages_[i], &still_pending)) {
       update_pages = true;
-      if (IsPageVisible(pending_pages_[i]))
+      if (client_ && IsPageVisible(pending_pages_[i]))
         client_->Invalidate(GetPageScreenRect(pending_pages_[i]));
     }
   }
   pending_pages_.swap(still_pending);
   if (update_pages)
     LoadPageInfo(true);
 }
 
 void PDFiumEngine::OnNewDataAvailable() {
+  if (!client_)
+    return;
   client_->DocumentLoadProgress(doc_loader_.GetAvailableData(),
                                 doc_loader_.document_size());
 }
 
 void PDFiumEngine::OnDocumentComplete() {
   if (!doc_ || !form_) {
     file_access_.m_FileLen = doc_loader_.document_size();
     LoadDocument();
     return;
   }
 
   bool need_update = false;
   for (size_t i = 0; i < pages_.size(); ++i) {
     if (pages_[i]->available())
       continue;
 
     pages_[i]->set_available(true);
     // We still need to call IsPageAvail() even if the whole document is
     // already downloaded.
     FPDFAvail_IsPageAvail(fpdf_availability_, i, &download_hints_);
     need_update = true;
-    if (IsPageVisible(i))
+    if (client_ && IsPageVisible(i))
       client_->Invalidate(GetPageScreenRect(i));
   }
   if (need_update)
     LoadPageInfo(true);
 
   FinishLoadingDocument();
 }
 
 void PDFiumEngine::FinishLoadingDocument() {
   DCHECK(doc_loader_.IsDocumentComplete() && doc_);
   if (called_do_document_action_)
     return;
   called_do_document_action_ = true;
 
   // These can only be called now, as the JS might end up needing a page.
   FORM_DoDocumentJSAction(form_);
   FORM_DoDocumentOpenAction(form_);
   if (most_visible_page_ != -1) {
     FPDF_PAGE new_page = pages_[most_visible_page_]->GetPage();
     FORM_DoPageAAction(new_page, form_, FPDFPAGE_AACTION_OPEN);
   }
 
-  if (doc_) // This can only happen if loading |doc_| fails.
+  if (doc_ && client_) // This can only happen if loading |doc_| fails.
     client_->DocumentLoadComplete(pages_.size());
 }
 
 void PDFiumEngine::UnsupportedFeature(int type) {
+  if (!client_)
+    return;
+
   std::string feature;
   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:
@@ skipping 85 matching lines @@
   if (HasPermission(PDFEngine::PERMISSION_PRINT_HIGH_QUALITY))
     return PrintPagesAsPDF(page_ranges, page_range_count, print_settings);
   else if (HasPermission(PDFEngine::PERMISSION_PRINT_LOW_QUALITY))
     return PrintPagesAsRasterPDF(page_ranges, page_range_count, print_settings);
   return pp::Resource();
 }
 
 pp::Buffer_Dev PDFiumEngine::PrintPagesAsRasterPDF(
     const PP_PrintPageNumberRange_Dev* page_ranges, uint32_t page_range_count,
     const PP_PrintSettings_Dev& print_settings) {
+  if (!client_)
+    return pp::Buffer_Dev();
+
   if (!page_range_count)
     return pp::Buffer_Dev();
 
   // If document is not downloaded yet, disable printing.
   if (doc_ && !doc_loader_.IsDocumentComplete())
     return pp::Buffer_Dev();
 
   FPDF_DOCUMENT output_doc = FPDF_CreateNewDocument();
   if (!output_doc)
     return pp::Buffer_Dev();
@@ skipping 102 matching lines @@
     FPDF_CopyViewerPreferences(output_doc, doc_);
     FitContentsToPrintableAreaIfRequired(output_doc, print_settings);
     // Now flatten all the output pages.
     buffer = GetFlattenedPrintData(output_doc);
   }
   FPDF_CloseDocument(output_doc);
   return buffer;
 }
 
 pp::Buffer_Dev PDFiumEngine::GetFlattenedPrintData(const FPDF_DOCUMENT& doc) {
+  if (!client_)
+    return pp::Buffer_Dev();
+
   int page_count = FPDF_GetPageCount(doc);
   bool flatten_succeeded = true;
   for (int i = 0; i < page_count; ++i) {
     FPDF_PAGE page = FPDF_LoadPage(doc, i);
     DCHECK(page);
     if (page) {
       int flatten_ret = FPDFPage_Flatten(page, FLAT_PRINT);
       FPDF_ClosePage(page);
       if (flatten_ret == FLATTEN_FAIL) {
         flatten_succeeded = false;
@@ skipping 84 matching lines @@
     for (int i = 0; i < num_pages; ++i) {
       FPDF_PAGE page = FPDF_LoadPage(doc, i);
       TransformPDFPageForPrinting(page, print_settings);
       FPDF_ClosePage(page);
     }
   }
 }
 
 void PDFiumEngine::SaveSelectedFormForPrint() {
   FORM_ForceToKillFocus(form_);
+  if (!client_)
+    return;
   client_->FormTextFieldFocusChange(false);
 }
 
 void PDFiumEngine::PrintEnd() {
   FORM_DoDocumentAAction(form_, FPDFDOC_AACTION_DP);
 }
 
 PDFiumPage::Area PDFiumEngine::GetCharIndex(
     const pp::MouseInputEvent& event, int* page_index,
     int* char_index, PDFiumPage::LinkTarget* target) {
@@ skipping 26 matching lines @@
     if (progressive_paints_[i].page_index == page)
       return PDFiumPage::NONSELECTABLE_AREA;
   }
 
   *page_index = page;
   return pages_[page]->GetCharIndex(point, current_rotation_, char_index,
                                     target);
 }
 
 bool PDFiumEngine::OnMouseDown(const pp::MouseInputEvent& event) {
+  if (!client_)
+    return false;
+
   if (event.GetButton() != PP_INPUTEVENT_MOUSEBUTTON_LEFT)
     return false;
 
   SelectionChangeInvalidator selection_invalidator(this);
   selection_.clear();
 
   int page_index = -1;
   int char_index = -1;
   PDFiumPage::LinkTarget target;
   PDFiumPage::Area area = GetCharIndex(event, &page_index,
@@ skipping 91 matching lines @@
   }
 
   if (!selecting_)
     return false;
 
   selecting_ = false;
   return true;
 }
 
 bool PDFiumEngine::OnMouseMove(const pp::MouseInputEvent& event) {
+  if (!client_)
+    return false;
+
   int page_index = -1;
   int char_index = -1;
   PDFiumPage::Area area = GetCharIndex(event, &page_index, &char_index, NULL);
   if (!selecting_) {
     PP_CursorType_Dev cursor;
     switch (area) {
       case PDFiumPage::TEXT_AREA:
         cursor = PP_CURSORTYPE_IBEAM;
         break;
       case PDFiumPage::WEBLINK_AREA:
@@ skipping 101 matching lines @@
 
     int count = pages_[page_index]->GetCharCount();
     selection_.push_back(
         PDFiumRange(pages_[page_index], count, count - char_index));
   }
 
   return true;
 }
 
 bool PDFiumEngine::OnKeyDown(const pp::KeyboardInputEvent& event) {
+  if (!client_)
+    return false;
+
   if (last_page_mouse_down_ == -1)
     return false;
 
   bool rv = !!FORM_OnKeyDown(
       form_, pages_[last_page_mouse_down_]->GetPage(),
       event.GetKeyCode(), event.GetModifiers());
 
   if (event.GetKeyCode() == ui::VKEY_BACK ||
       event.GetKeyCode() == ui::VKEY_ESCAPE) {
     // Chrome doesn't send char events for backspace or escape keys, see
@@ skipping 29 matching lines @@
     return false;
 
   base::string16 str = base::UTF8ToUTF16(event.GetCharacterText().AsString());
   return !!FORM_OnChar(
       form_, pages_[last_page_mouse_down_]->GetPage(),
       str[0],
       event.GetModifiers());
 }
 
 void PDFiumEngine::StartFind(const char* text, bool case_sensitive) {
+  if (!client_)
+    return;
+
   // We can get a call to StartFind before we have any page information (i.e.
   // before the first call to LoadDocument has happened). Handle this case.
   if (pages_.empty())
     return;
 
   bool first_search = false;
   int character_to_start_searching_from = 0;
   if (current_find_text_ != text) {  // First time we search for this text.
     first_search = true;
     std::vector<PDFiumRange> old_selection = selection_;
@@ skipping 94 matching lines @@
   }
 
   FPDFText_FindClose(find);
 }
 
 void PDFiumEngine::SearchUsingICU(const base::string16& term,
                                   bool case_sensitive,
                                   bool first_search,
                                   int character_to_start_searching_from,
                                   int current_page) {
+  if (!client_)
+    return;
+
   base::string16 page_text;
   int text_length = pages_[current_page]->GetCharCount();
   if (character_to_start_searching_from) {
     text_length -= character_to_start_searching_from;
   } else if (!first_search &&
              last_character_index_to_search_ != -1 &&
              current_page == last_page_to_search_) {
     text_length = last_character_index_to_search_;
   }
   if (text_length <= 0)
@@ skipping 14 matching lines @@
     int start = FPDFText_GetCharIndexFromTextIndex(
         pages_[current_page]->GetTextPage(), temp_start);
     int end = FPDFText_GetCharIndexFromTextIndex(
         pages_[current_page]->GetTextPage(),
         temp_start + results[i].length);
     AddFindResult(PDFiumRange(pages_[current_page], start, end - start));
   }
 }
 
 void PDFiumEngine::AddFindResult(const PDFiumRange& result) {
+  if (!client_)
+    return;
+
   // Figure out where to insert the new location, since we could have
   // started searching midway and now we wrapped.
   size_t i;
   int page_index = result.page_index();
   int char_index = result.char_index();
   for (i = 0; i < find_results_.size(); ++i) {
     if (find_results_[i].page_index() > page_index ||
         (find_results_[i].page_index() == page_index &&
          find_results_[i].char_index() > char_index)) {
       break;
     }
   }
   find_results_.insert(find_results_.begin() + i, result);
   UpdateTickMarks();
 
   if (current_find_index_ == -1) {
     // Select the first match.
     SelectFindResult(true);
   } else if (static_cast<int>(i) <= current_find_index_) {
     // Update the current match index
     current_find_index_++;
     client_->NotifySelectedFindResultChanged(current_find_index_);
   }
   client_->NotifyNumberOfFindResultsChanged(find_results_.size(), false);
 }
 
 bool PDFiumEngine::SelectFindResult(bool forward) {
+  if (!client_)
+    return false;
+
   if (find_results_.empty()) {
     NOTREACHED();
     return false;
   }
 
   SelectionChangeInvalidator selection_invalidator(this);
 
   // Move back/forward through the search locations we previously found.
   if (forward) {
     if (++current_find_index_ == static_cast<int>(find_results_.size()))
@@ skipping 51 matching lines @@
   next_page_to_search_ = -1;
   last_page_to_search_ = -1;
   last_character_index_to_search_ = -1;
   current_find_index_ = -1;
   current_find_text_.clear();
   UpdateTickMarks();
   find_factory_.CancelAll();
 }
 
 void PDFiumEngine::UpdateTickMarks() {
+  if (!client_)
+    return;
+
   std::vector<pp::Rect> tickmarks;
   for (size_t i = 0; i < find_results_.size(); ++i) {
     pp::Rect rect;
     // Always use an origin of 0,0 since scroll positions don't affect tickmark.
     std::vector<pp::Rect> rects = find_results_[i].GetScreenRects(
       pp::Point(0, 0), current_zoom_, current_rotation_);
     for (size_t j = 0; j < rects.size(); ++j)
       rect = rect.Union(rects[j]);
     tickmarks.push_back(rect);
   }
@@ skipping 14 matching lines @@
   current_rotation_ = (current_rotation_ + 1) % 4;
   InvalidateAllPages();
 }
 
 void PDFiumEngine::RotateCounterclockwise() {
   current_rotation_ = (current_rotation_ - 1) % 4;
   InvalidateAllPages();
 }
 
 void PDFiumEngine::InvalidateAllPages() {
+  if (!client_)
+    return;
+
   selection_.clear();
   find_results_.clear();
 
   CancelPaints();
   LoadPageInfo(true);
   UpdateTickMarks();
   client_->Invalidate(pp::Rect(plugin_size_));
 }
 
 std::string PDFiumEngine::GetSelectedText() {
@@ skipping 109 matching lines @@
   }
 
   FPDFBitmap_Destroy(bitmap);
 }
 
 void PDFiumEngine::SetGrayscale(bool grayscale) {
   render_grayscale_ = grayscale;
 }
 
 void PDFiumEngine::OnCallback(int id) {
+  if (!client_)
+    return;
+
   if (!timers_.count(id))
     return;
 
   timers_[id].second(id);
   if (timers_.count(id))  // The callback might delete the timer.
     client_->ScheduleCallback(id, timers_[id].first);
 }
 
 std::string PDFiumEngine::GetPageAsJSON(int index) {
   if (!(HasPermission(PERMISSION_COPY) ||
@@ skipping 10 matching lines @@
   base::JSONWriter::Write(node.get(), &page_json);
   return page_json;
 }
 
 bool PDFiumEngine::GetPrintScaling() {
   return !!FPDF_VIEWERREF_GetPrintScaling(doc_);
 }
 
 void PDFiumEngine::AppendBlankPages(int num_pages) {
   DCHECK(num_pages != 0);
+  if (!client_)
+    return;
 
   if (!doc_)
     return;
 
   selection_.clear();
   pending_pages_.clear();
 
   // Delete all pages except the first one.
   while (pages_.size() > 1) {
     delete pages_.back();
@@ skipping 32 matching lines @@
     FPDFPage_New(doc_, i, width_in_points, height_in_points);
     pages_.push_back(new PDFiumPage(this, i, page_rect, true));
   }
 
   CalculateVisiblePages();
   if (document_size_ != old_document_size)
     client_->DocumentSizeUpdated(document_size_);
 }
 
 void PDFiumEngine::LoadDocument() {
+  if (!client_)
+    return;
+
   // Check if the document is ready for loading. If it isn't just bail for now,
   // we will call LoadDocument() again later.
   if (!doc_ && !doc_loader_.IsDocumentComplete() &&
       !FPDFAvail_IsDocAvail(fpdf_availability_, &download_hints_)) {
     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_)
@@ skipping 30 matching lines @@
 
   if (!doc_ && FPDF_GetLastError() == FPDF_ERR_PASSWORD)
     *needs_password = true;
 
   return doc_ != NULL;
 }
 
 void PDFiumEngine::GetPasswordAndLoad() {
   getting_password_ = true;
   DCHECK(!doc_ && FPDF_GetLastError() == FPDF_ERR_PASSWORD);
+  if (!client_)
+    return;
+
   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()) {
     password_text = password.AsString();
     if (!password_text.empty())
       password_given = true;
   }
   ContinueLoadingDocument(password_given, password_text);
 }
 
 void PDFiumEngine::ContinueLoadingDocument(
     bool has_password,
     const std::string& password) {
+  if (!client_)
+    return;
+
   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;
   if (password_incorrect && password_tries_remaining_ > 0) {
     GetPasswordAndLoad();
     return;
   }
 
@@ skipping 28 matching lines @@
     CheckPageAvailable(FPDFAvail_GetFirstPageNum(doc_), &pending_pages_);
   }
 
   LoadPageInfo(false);
 
   if (doc_loader_.IsDocumentComplete())
     FinishLoadingDocument();
 }
 
 void PDFiumEngine::LoadPageInfo(bool reload) {
+  if (!client_)
+    return;
+
   pending_pages_.clear();
   pp::Size old_document_size = document_size_;
   document_size_ = pp::Size();
   std::vector<pp::Rect> page_rects;
   int page_count = FPDF_GetPageCount(doc_);
   bool doc_complete = doc_loader_.IsDocumentComplete();
   for (int i = 0; i < page_count; ++i) {
     if (i != 0) {
       // Add space for horizontal separator.
       document_size_.Enlarge(0, kPageSeparatorThickness);
@@ skipping 155 matching lines @@
   progressive.rect = dirty;
   progressive.page_index = page_index;
   progressive.bitmap = NULL;
   progressive.painted_ = false;
   progressive_paints_.push_back(progressive);
   return progressive_paints_.size() - 1;
 }
 
 bool PDFiumEngine::ContinuePaint(int progressive_index,
                                  pp::ImageData* image_data) {
+  if (!client_)
+    return false;
+
 #if defined(OS_LINUX)
   g_last_instance_id = client_->GetPluginInstance()->pp_instance();
 #endif
 
   int rv;
   int page_index = progressive_paints_[progressive_index].page_index;
   last_progressive_start_time_ = base::Time::Now();
   if (progressive_paints_[progressive_index].bitmap) {
     rv = FPDF_RenderPage_Continue(
         pages_[page_index]->GetPage(), static_cast<IFSDK_PAUSE*>(this));
@@ skipping 10 matching lines @@
         progressive_paints_[progressive_index].bitmap,
         pages_[page_index]->GetPage(), start_x, start_y, size_x, size_y,
         current_rotation_,
         GetRenderingFlags(), static_cast<IFSDK_PAUSE*>(this));
   }
   return rv != FPDF_RENDER_TOBECOUNTINUED;
 }
 
 void PDFiumEngine::FinishPaint(int progressive_index,
                                pp::ImageData* image_data) {
+  if (!client_)
+    return;
+
   int page_index = progressive_paints_[progressive_index].page_index;
   pp::Rect dirty_in_screen = progressive_paints_[progressive_index].rect;
   FPDF_BITMAP bitmap = progressive_paints_[progressive_index].bitmap;
   int start_x, start_y, size_x, size_y;
   GetPDFiumRect(
       page_index, dirty_in_screen, &start_x, &start_y, &size_x, &size_y);
 
   // Draw the forms.
   FPDF_FFLDraw(
       form_, bitmap, pages_[page_index]->GetPage(), start_x, start_y, size_x,
@@ skipping 173 matching lines @@
   *start_x = page_rect.x();
   *start_y = page_rect.y();
   *size_x = page_rect.width();
   *size_y = page_rect.height();
 }
 
 int PDFiumEngine::GetRenderingFlags() const {
   int flags = FPDF_LCD_TEXT | FPDF_NO_CATCH;
   if (render_grayscale_)
     flags |= FPDF_GRAYSCALE;
-  if (client_->IsPrintPreview())
+  if (client_ && client_->IsPrintPreview())
     flags |= FPDF_PRINTING;
   return flags;
 }
 
 pp::Rect PDFiumEngine::GetVisibleRect() const {
   pp::Rect rv;
   rv.set_x(static_cast<int>(position_.x() / current_zoom_));
   rv.set_y(static_cast<int>(position_.y() / current_zoom_));
   rv.set_width(static_cast<int>(ceil(plugin_size_.width() / current_zoom_)));
   rv.set_height(static_cast<int>(ceil(plugin_size_.height() / current_zoom_)));
@@ skipping 74 matching lines @@
   for (size_t i = 0; i < new_selections.size(); ++i) {
     for (size_t j = 0; j < old_selections_.size(); ++j) {
       if (new_selections[i] == old_selections_[j]) {
         // Rectangle was selected before and after, so no need to invalidate it.
         // Mark the rectangles by setting them to empty.
         new_selections[i] = old_selections_[j] = pp::Rect();
       }
     }
   }
 
-  for (size_t i = 0; i < old_selections_.size(); ++i) {
-    if (!old_selections_[i].IsEmpty())
-      engine_->client_->Invalidate(old_selections_[i]);
-  }
-  for (size_t i = 0; i < new_selections.size(); ++i) {
-    if (!new_selections[i].IsEmpty())
-      engine_->client_->Invalidate(new_selections[i]);
+  if (engine_->client_) {
+    for (size_t i = 0; i < old_selections_.size(); ++i) {
+      if (!old_selections_[i].IsEmpty())
+        engine_->client_->Invalidate(old_selections_[i]);
+    }
+    for (size_t i = 0; i < new_selections.size(); ++i) {
+      if (!new_selections[i].IsEmpty())
+        engine_->client_->Invalidate(new_selections[i]);
+    }
   }
   engine_->OnSelectionChanged();
 }
 
 void
 PDFiumEngine::SelectionChangeInvalidator::GetVisibleSelectionsScreenRects(
     std::vector<pp::Rect>* rects) {
   pp::Rect visible_rect = engine_->GetVisibleRect();
   for (size_t i = 0; i < engine_->selection_.size(); ++i) {
     int page_index = engine_->selection_[i].page_index();
@@ skipping 35 matching lines @@
 
 void PDFiumEngine::SetCurrentPage(int index) {
   if (index == most_visible_page_ || !form_)
     return;
   if (most_visible_page_ != -1 && called_do_document_action_) {
     FPDF_PAGE old_page = pages_[most_visible_page_]->GetPage();
     FORM_DoPageAAction(old_page, form_, FPDFPAGE_AACTION_CLOSE);
   }
   most_visible_page_ = index;
 #if defined(OS_LINUX)
+  if (client_)
     g_last_instance_id = client_->GetPluginInstance()->pp_instance();
 #endif
   if (most_visible_page_ != -1 && called_do_document_action_) {
     FPDF_PAGE new_page = pages_[most_visible_page_]->GetPage();
     FORM_DoPageAAction(new_page, form_, FPDFPAGE_AACTION_OPEN);
   }
 }
 
 void PDFiumEngine::TransformPDFPageForPrinting(
     FPDF_PAGE page,
@@ skipping 140 matching lines @@
                                    double right,
                                    double bottom) {
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
   int page_index = engine->GetVisiblePageIndex(page);
   if (page_index == -1) {
     // This can sometime happen when the page is closed because it went off
     // screen, and PDFium invalidates the control as it's being deleted.
     return;
   }
 
+  if (!engine->client_)
+    return;
+
   pp::Rect rect = engine->pages_[page_index]->PageToScreen(
       engine->GetVisibleRect().point(), engine->current_zoom_, left, top, right,
       bottom, engine->current_rotation_);
   engine->client_->Invalidate(rect);
 }
 
 void PDFiumEngine::Form_OutputSelectedRect(FPDF_FORMFILLINFO* param,
                                            FPDF_PAGE page,
                                            double left,
                                            double top,
@@ skipping 13 matching lines @@
 
 void PDFiumEngine::Form_SetCursor(FPDF_FORMFILLINFO* param, int cursor_type) {
   // We don't need this since it's not enough to change the cursor in all
   // scenarios.  Instead, we check which form field we're under in OnMouseMove.
 }
 
 int PDFiumEngine::Form_SetTimer(FPDF_FORMFILLINFO* param,
                                 int elapse,
                                 TimerCallback timer_func) {
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
+  if (!engine->client_)
+    return -1;
+
   engine->timers_[++engine->next_timer_id_] =
       std::pair<int, TimerCallback>(elapse, timer_func);
   engine->client_->ScheduleCallback(engine->next_timer_id_, elapse);
   return engine->next_timer_id_;
 }
 
 void PDFiumEngine::Form_KillTimer(FPDF_FORMFILLINFO* param, int timer_id) {
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
   engine->timers_.erase(timer_id);
 }
@@ skipping 44 matching lines @@
   return engine->pages_[index]->GetPage();
 }
 
 int PDFiumEngine::Form_GetRotation(FPDF_FORMFILLINFO* param, FPDF_PAGE page) {
   return 0;
 }
 
 void PDFiumEngine::Form_ExecuteNamedAction(FPDF_FORMFILLINFO* param,
                                            FPDF_BYTESTRING named_action) {
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
+  if (!engine->client_)
+    return;
+
   std::string action(named_action);
   if (action == "Print") {
     engine->client_->Print();
     return;
   }
 
   int index = engine->last_page_mouse_down_;
   /* Don't try to calculate the most visible page if we don't have a left click
      before this event (this code originally copied Form_GetCurrentPage which of
      course needs to do that and which doesn't have recursion). This can end up
@@ skipping 24 matching lines @@
                                           FPDF_WIDESTRING value,
                                           FPDF_DWORD valueLen,
                                           FPDF_BOOL is_focus) {
   // Do nothing for now.
   // TODO(gene): use this signal to trigger OSK.
 }
 
 void PDFiumEngine::Form_DoURIAction(FPDF_FORMFILLINFO* param,
                                     FPDF_BYTESTRING uri) {
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
+  if (!engine->client_)
+    return;
   engine->client_->NavigateTo(std::string(uri), false);
 }
 
 void PDFiumEngine::Form_DoGoToAction(FPDF_FORMFILLINFO* param,
                                      int page_index,
                                      int zoom_mode,
                                      float* position_array,
                                      int size_of_array) {
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
+  if (!engine->client_)
+    return;
   engine->client_->ScrollToPage(page_index);
 }
 
 int PDFiumEngine::Form_Alert(IPDF_JSPLATFORM* param,
                              FPDF_WIDESTRING message,
                              FPDF_WIDESTRING title,
                              int type,
                              int icon) {
   // See fpdfformfill.h for these values.
   enum AlertType {
     ALERT_TYPE_OK = 0,
     ALERT_TYPE_OK_CANCEL,
     ALERT_TYPE_YES_ON,
     ALERT_TYPE_YES_NO_CANCEL
   };
 
   enum AlertResult {
     ALERT_RESULT_OK = 1,
     ALERT_RESULT_CANCEL,
     ALERT_RESULT_NO,
     ALERT_RESULT_YES
   };
 
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
+  if (!engine->client_)
+    return ALERT_RESULT_CANCEL;
+
   std::string message_str =
       base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(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) {
+  PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
+  if (!engine->client_)
+    return -1;
+
   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));
 
-  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;
 }
 
 int PDFiumEngine::Form_GetFilePath(IPDF_JSPLATFORM* param,
                                    void* file_path,
                                    int length) {
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
+  if (!engine->client_)
+    return -1;
+
   std::string rv = engine->client_->GetURL();
   if (file_path && rv.size() <= static_cast<size_t>(length))
     memcpy(file_path, rv.c_str(), rv.size());
   return rv.size();
 }
 
 void PDFiumEngine::Form_Mail(IPDF_JSPLATFORM* param,
                              void* mail_data,
                              int length,
                              FPDF_BOOL ui,
                              FPDF_WIDESTRING to,
                              FPDF_WIDESTRING subject,
                              FPDF_WIDESTRING cc,
                              FPDF_WIDESTRING bcc,
                              FPDF_WIDESTRING message) {
   DCHECK(length == 0);  // Don't handle attachments; no way with mailto.
+  PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
+  if (!engine->client_)
+    return;
+
   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));
 
-  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);
+  if (!engine->client_)
+    return;
   engine->client_->Print();
 }
 
 void PDFiumEngine::Form_SubmitForm(IPDF_JSPLATFORM* param,
                                    void* form_data,
                                    int length,
                                    FPDF_WIDESTRING url) {
+  PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
+  if (!engine->client_)
+    return;
   std::string url_str =
       base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(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);
+  if (!engine->client_)
+    return;
   engine->client_->ScrollToPage(page_number);
 }
 
 int PDFiumEngine::Form_Browse(IPDF_JSPLATFORM* param,
                               void* file_path,
                               int length) {
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
+  if (!engine->client_)
+    return -1;
+
   std::string path = engine->client_->ShowFileSelectionDialog();
   if (path.size() + 1 <= static_cast<size_t>(length))
     memcpy(file_path, &path[0], path.size() + 1);
   return path.size() + 1;
 }
 
 FPDF_BOOL PDFiumEngine::Pause_NeedToPauseNow(IFSDK_PAUSE* param) {
   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
   return (base::Time::Now() - engine->last_progressive_start_time_).
       InMilliseconds() > engine->progressive_paint_timeout_;
@@ skipping 236 matching lines @@
     double* height) {
   FPDF_DOCUMENT doc = FPDF_LoadMemDocument(pdf_buffer, pdf_buffer_size, NULL);
   if (!doc)
     return false;
   bool success = FPDF_GetPageSizeByIndex(doc, page_number, width, height) != 0;
   FPDF_CloseDocument(doc);
   return success;
 }
 
 }  // namespace chrome_pdf