Add functionality for copying text within form text fields and form combobox text fields

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 1607 matching lines @@
       FPDF_PAGE page = FPDF_LoadPage(doc, i);
       TransformPDFPageForPrinting(page, print_settings);
       FPDF_ClosePage(page);
     }
   }
 }
 
 void PDFiumEngine::SaveSelectedFormForPrint() {
   FORM_ForceToKillFocus(form_);
   client_->FormTextFieldFocusChange(false);
+  SetInFormTextArea(false);
+}
+
+void PDFiumEngine::SetFormSelectedText(FPDF_FORMHANDLE form_handle,
+                                       FPDF_PAGE page) {
+  unsigned long form_sel_text_len =
+      FORM_GetSelectedText(form_handle, page, nullptr, 0);
+
+  // Initial length = 2 (not 0) because an empty NUL-terminated wide string is

[Lei Zhang, 2017/06/21 00:19:45]

Not sure why I didn't mention this earlier, but the "Initial length = 2" part
sounds weird too. How about:

Check to see if there is selected text in the form. When |form_sel_text_len| is
2, that represents a wide string with just a NUL-terminator.

[drgage, 2017/06/21 01:30:23]

Done.

+  // two bytes long
+  if (form_sel_text_len <= 2)
+    return;
+
+  base::string16 selected_form_text16;
+  PDFiumAPIStringBufferSizeInBytesAdapter<base::string16> string_adapter(
+      &selected_form_text16, form_sel_text_len, false);
+  string_adapter.Close(FORM_GetSelectedText(
+      form_handle, page, string_adapter.GetData(), form_sel_text_len));
+
+  std::string selected_form_text = UTF16ToUTF8(selected_form_text16);
+  if (!selected_form_text.empty()) {
+    pp::PDF::SetSelectedText(GetPluginInstance(), selected_form_text.c_str());
+  }
 }
 
 void PDFiumEngine::PrintEnd() {
   FORM_DoDocumentAAction(form_, FPDFDOC_AACTION_DP);
 }
 
 PDFiumPage::Area PDFiumEngine::GetCharIndex(const pp::MouseInputEvent& event,
                                             int* page_index,
                                             int* char_index,
                                             int* form_type,
@@ skipping 76 matching lines @@
     return false;
 
   if (page_index != -1) {
     last_page_mouse_down_ = page_index;
     double page_x, page_y;
     pp::Point point = event.GetPosition();
     DeviceToPage(page_index, point.x(), point.y(), &page_x, &page_y);
 
     FORM_OnLButtonDown(form_, pages_[page_index]->GetPage(), 0, page_x, page_y);
     if (form_type > FPDF_FORMFIELD_UNKNOWN) {  // returns -1 sometimes...
-      mouse_down_state_.Set(PDFiumPage::NONSELECTABLE_AREA, target);
+      mouse_down_state_.Set(pages_[page_index]->FormTypeToArea(form_type),

[Lei Zhang, 2017/06/21 00:19:45]

If PDFiumPage::FormTypeToArea() became a static method, then you can just write:
PDFiumPage::FormTypeToArea(form_type) since it no longer needs to be tied to any
particular instance of PDFiumPage.

[drgage, 2017/06/21 01:30:23]

Done.

+                            target);
+
       bool is_valid_control = (form_type == FPDF_FORMFIELD_TEXTFIELD ||
                                form_type == FPDF_FORMFIELD_COMBOBOX);
+
+// TODO(bug_62400): figure out selection and copying
+// for XFA fields
 #if defined(PDF_ENABLE_XFA)
       is_valid_control |= (form_type == FPDF_FORMFIELD_XFA);
 #endif
       client_->FormTextFieldFocusChange(is_valid_control);
+      SetInFormTextArea(is_valid_control);
       return true;  // Return now before we get into the selection code.
     }
   }
-
   client_->FormTextFieldFocusChange(false);
+  SetInFormTextArea(false);
 
   if (area != PDFiumPage::TEXT_AREA)
     return true;  // Return true so WebKit doesn't do its own highlighting.
 
   if (event.GetClickCount() == 1) {
     OnSingleClick(page_index, char_index);
   } else if (event.GetClickCount() == 2 || event.GetClickCount() == 3) {
     OnMultipleClick(event.GetClickCount(), page_index, char_index);
   }
 
@@ skipping 55 matching lines @@
       bool alt_key = !!(modifiers & PP_INPUTEVENT_MODIFIER_ALTKEY);
       bool ctrl_key = !!(modifiers & PP_INPUTEVENT_MODIFIER_CONTROLKEY);
       bool meta_key = !!(modifiers & PP_INPUTEVENT_MODIFIER_METAKEY);
       bool shift_key = !!(modifiers & PP_INPUTEVENT_MODIFIER_SHIFTKEY);
 
       WindowOpenDisposition disposition = ui::DispositionFromClick(
           middle_button, alt_key, ctrl_key, meta_key, shift_key);
 
       client_->NavigateTo(target.url, disposition);
       client_->FormTextFieldFocusChange(false);
+      SetInFormTextArea(false);
       return true;
     }
     if (area == PDFiumPage::DOCLINK_AREA) {
       client_->ScrollToPage(target.page);
       client_->FormTextFieldFocusChange(false);
+      SetInFormTextArea(false);
       return true;
     }
   }
 
   // Prevent middle mouse button from selecting texts.
   if (event.GetButton() == PP_INPUTEVENT_MOUSEBUTTON_MIDDLE)
     return false;
 
   if (page_index != -1) {
     double page_x, page_y;
     pp::Point point = event.GetPosition();
     DeviceToPage(page_index, point.x(), point.y(), &page_x, &page_y);
     FORM_OnLButtonUp(form_, pages_[page_index]->GetPage(), 0, page_x, page_y);
   }
 
+  if (area == PDFiumPage::FORM_TEXT_AREA)
+    SetFormSelectedText(form_, pages_[last_page_mouse_down_]->GetPage());
+
   if (!selecting_)
     return false;
 
   SetSelecting(false);
   return true;
 }
 
 bool PDFiumEngine::OnMouseMove(const pp::MouseInputEvent& event) {
   int page_index = -1;
   int char_index = -1;
@@ skipping 11 matching lines @@
     PP_CursorType_Dev cursor;
     switch (area) {
       case PDFiumPage::TEXT_AREA:
         cursor = PP_CURSORTYPE_IBEAM;
         break;
       case PDFiumPage::WEBLINK_AREA:
       case PDFiumPage::DOCLINK_AREA:
         cursor = PP_CURSORTYPE_HAND;
         break;
       case PDFiumPage::NONSELECTABLE_AREA:
+      case PDFiumPage::FORM_TEXT_AREA:
       default:
         switch (form_type) {
           case FPDF_FORMFIELD_PUSHBUTTON:
           case FPDF_FORMFIELD_CHECKBOX:
           case FPDF_FORMFIELD_RADIOBUTTON:
           case FPDF_FORMFIELD_COMBOBOX:
           case FPDF_FORMFIELD_LISTBOX:
             cursor = PP_CURSORTYPE_HAND;
             break;
           case FPDF_FORMFIELD_TEXTFIELD:
@@ skipping 106 matching lines @@
     // http://chrome-corpsvn.mtv.corp.google.com/viewvc?view=rev&root=chrome&revision=31805
     // for more information.  So just fake one since PDFium uses it.
     std::string str;
     str.push_back(event.GetKeyCode());
     pp::KeyboardInputEvent synthesized(pp::KeyboardInputEvent(
         client_->GetPluginInstance(), PP_INPUTEVENT_TYPE_CHAR,
         event.GetTimeStamp(), event.GetModifiers(), event.GetKeyCode(), str));
     OnChar(synthesized);
   }
 
+  // If form selected text is empty and key pressed within form text area,
+  // plugin text selection should be cleared.
+  if (in_form_text_area_ &&
+      FORM_GetSelectedText(form_, pages_[last_page_mouse_down_]->GetPage(),
+                           nullptr, 0) <= 2)
+    pp::PDF::SetSelectedText(GetPluginInstance(), "");
+
   return rv;
 }
 
 bool PDFiumEngine::OnKeyUp(const pp::KeyboardInputEvent& event) {
   if (last_page_mouse_down_ == -1)
     return false;
 
+  if (in_form_text_area_) {
+    if (event.GetKeyCode() == ui::VKEY_SHIFT)
+      SetFormSelectedText(form_, pages_[last_page_mouse_down_]->GetPage());
+  }
+
   return !!FORM_OnKeyUp(form_, pages_[last_page_mouse_down_]->GetPage(),
                         event.GetKeyCode(), event.GetModifiers());
 }
 
 bool PDFiumEngine::OnChar(const pp::KeyboardInputEvent& event) {
   if (last_page_mouse_down_ == -1)
     return false;
 
   base::string16 str = base::UTF8ToUTF16(event.GetCharacterText().AsString());
   return !!FORM_OnChar(form_, pages_[last_page_mouse_down_]->GetPage(), str[0],
@@ skipping 1541 matching lines @@
   client_->ScrollToPage(most_visible_page);
 }
 
 void PDFiumEngine::SetSelecting(bool selecting) {
   bool was_selecting = selecting_;
   selecting_ = selecting;
   if (selecting_ != was_selecting)
     client_->IsSelectingChanged(selecting);
 }
 
+void PDFiumEngine::SetInFormTextArea(bool in_form_text_area) {
+  in_form_text_area_ = in_form_text_area;
+}
+
 void PDFiumEngine::ScheduleTouchTimer(const pp::TouchInputEvent& evt) {
   touch_timers_[++next_touch_timer_id_] = evt;
   client_->ScheduleTouchTimerCallback(next_touch_timer_id_,
                                       kTouchLongPressTimeoutMs);
 }
 
 void PDFiumEngine::KillTouchTimer(int timer_id) {
   touch_timers_.erase(timer_id);
 }
 
@@ skipping 569 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