Remove deprecated base::Value API usage from //pdf.

Use base::Value::Dict and base::Value::List directly and stop using
deprecated base::Value APIs.

Change-Id: I55f578932a212d526b1d94922c8ce13f8d204e67
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3577430
Reviewed-by: K. Moon <kmoon@chromium.org>
Commit-Queue: Lei Zhang <thestig@chromium.org>
Cr-Commit-Position: refs/heads/main@{#991715}

pdf/pdf_engine.h

@@ -426,7 +426,7 @@ class PDFEngine {
   // - "page" - an int Value.
   // - "children" - a list of Values, with each entry containing
   //   a dictionary Value of the same structure.
-  virtual base::Value GetBookmarks() = 0;
+  virtual base::Value::List GetBookmarks() = 0;
 
   // Append blank pages to make a 1-page document to a `num_pages` document.
   // Always retain the first page data.

pdf/pdf_view_plugin_base.cc

@@ -103,14 +103,14 @@ enum class PinchPhase {
 // If the "type" value of `message` is "foo", then the `reply_type` must be
 // "fooReply". The `message` from the embedder must have a "messageId" value
 // that will be copied to the reply message.
-base::Value PrepareReplyMessage(base::StringPiece reply_type,
-                                const base::Value::Dict& message) {
+base::Value::Dict PrepareReplyMessage(base::StringPiece reply_type,
+                                      const base::Value::Dict& message) {
   DCHECK_EQ(reply_type, *message.FindString("type") + "Reply");
 
   base::Value::Dict reply;
   reply.Set("type", reply_type);
   reply.Set("messageId", *message.FindString("messageId"));
-  return base::Value(std::move(reply));
+  return reply;
 }
 
 bool IsPrintPreviewUrl(base::StringPiece url) {
@@ -194,15 +194,15 @@ void PdfViewPluginBase::InitializeBase(std::unique_ptr<PDFiumEngine> engine,
 }
 
 void PdfViewPluginBase::ProposeDocumentLayout(const DocumentLayout& layout) {
-  base::Value message(base::Value::Type::DICTIONARY);
-  message.SetStringKey("type", "documentDimensions");
-  message.SetIntKey("width", layout.size().width());
-  message.SetIntKey("height", layout.size().height());
-  message.SetKey("layoutOptions", base::Value(layout.options().ToValue()));
-  base::Value page_dimensions_list(base::Value::Type::LIST);
+  base::Value::Dict message;
+  message.Set("type", "documentDimensions");
+  message.Set("width", layout.size().width());
+  message.Set("height", layout.size().height());
+  message.Set("layoutOptions", layout.options().ToValue());
+  base::Value::List page_dimensions;
   for (size_t i = 0; i < layout.page_count(); ++i)
-    page_dimensions_list.Append(base::Value(DictFromRect(layout.page_rect(i))));
-  message.SetKey("pageDimensions", std::move(page_dimensions_list));
+    page_dimensions.Append(base::Value(DictFromRect(layout.page_rect(i))));
+  message.Set("pageDimensions", std::move(page_dimensions));
   SendMessage(std::move(message));
 
   // Reload the accessibility tree on layout changes because the relative page
@@ -229,18 +229,18 @@ void PdfViewPluginBase::DidScroll(const gfx::Vector2d& offset) {
 void PdfViewPluginBase::ScrollToX(int x_screen_coords) {
   const float x_scroll_pos = x_screen_coords / device_scale_;
 
-  base::Value message(base::Value::Type::DICTIONARY);
-  message.SetStringKey("type", "setScrollPosition");
-  message.SetDoubleKey("x", x_scroll_pos);
+  base::Value::Dict message;
+  message.Set("type", "setScrollPosition");
+  message.Set("x", static_cast<double>(x_scroll_pos));
   SendMessage(std::move(message));
 }
 
 void PdfViewPluginBase::ScrollToY(int y_screen_coords) {
   const float y_scroll_pos = y_screen_coords / device_scale_;
 
-  base::Value message(base::Value::Type::DICTIONARY);
-  message.SetStringKey("type", "setScrollPosition");
-  message.SetDoubleKey("y", y_scroll_pos);
+  base::Value::Dict message;
+  message.Set("type", "setScrollPosition");
+  message.Set("y", static_cast<double>(y_scroll_pos));
   SendMessage(std::move(message));
 }
 
@@ -248,10 +248,10 @@ void PdfViewPluginBase::ScrollBy(const gfx::Vector2d& delta) {
   const float x_delta = delta.x() / device_scale_;
   const float y_delta = delta.y() / device_scale_;
 
-  base::Value message(base::Value::Type::DICTIONARY);
-  message.SetStringKey("type", "scrollBy");
-  message.SetDoubleKey("x", x_delta);
-  message.SetDoubleKey("y", y_delta);
+  base::Value::Dict message;
+  message.Set("type", "scrollBy");
+  message.Set("x", static_cast<double>(x_delta));
+  message.Set("y", static_cast<double>(y_delta));
   SendMessage(std::move(message));
 }
 
@@ -259,18 +259,18 @@ void PdfViewPluginBase::ScrollToPage(int page) {
   if (!engine_ || engine_->GetNumberOfPages() == 0)
     return;
 
-  base::Value message(base::Value::Type::DICTIONARY);
-  message.SetStringKey("type", "goToPage");
-  message.SetIntKey("page", page);
+  base::Value::Dict message;
+  message.Set("type", "goToPage");
+  message.Set("page", page);
   SendMessage(std::move(message));
 }
 
 void PdfViewPluginBase::NavigateTo(const std::string& url,
                                    WindowOpenDisposition disposition) {
-  base::Value message(base::Value::Type::DICTIONARY);
-  message.SetStringKey("type", "navigate");
-  message.SetStringKey("url", url);
-  message.SetIntKey("disposition", static_cast<int>(disposition));
+  base::Value::Dict message;
+  message.Set("type", "navigate");
+  message.Set("url", url);
+  message.Set("disposition", static_cast<int>(disposition));
   SendMessage(std::move(message));
 }
 
@@ -278,21 +278,21 @@ void PdfViewPluginBase::NavigateToDestination(int page,
                                               const float* x,
                                               const float* y,
                                               const float* zoom) {
-  base::Value message(base::Value::Type::DICTIONARY);
-  message.SetStringKey("type", "navigateToDestination");
-  message.SetIntKey("page", page);
+  base::Value::Dict message;
+  message.Set("type", "navigateToDestination");
+  message.Set("page", page);
   if (x)
-    message.SetDoubleKey("x", *x);
+    message.Set("x", static_cast<double>(*x));
   if (y)
-    message.SetDoubleKey("y", *y);
+    message.Set("y", static_cast<double>(*y));
   if (zoom)
-    message.SetDoubleKey("zoom", *zoom);
+    message.Set("zoom", static_cast<double>(*zoom));
   SendMessage(std::move(message));
 }
 
 void PdfViewPluginBase::NotifyTouchSelectionOccurred() {
-  base::Value message(base::Value::Type::DICTIONARY);
-  message.SetStringKey("type", "touchSelectionOccurred");
+  base::Value::Dict message;
+  message.Set("type", "touchSelectionOccurred");
   SendMessage(std::move(message));
 }
 
@@ -301,14 +301,14 @@ void PdfViewPluginBase::GetDocumentPassword(
   DCHECK(password_callback_.is_null());
   password_callback_ = std::move(callback);
 
-  base::Value message(base::Value::Type::DICTIONARY);
-  message.SetStringKey("type", "getPassword");
+  base::Value::Dict message;
+  message.Set("type", "getPassword");
   SendMessage(std::move(message));
 }
 
 void PdfViewPluginBase::Beep() {
-  base::Value message(base::Value::Type::DICTIONARY);
-  message.SetStringKey("type", "beep");
+  base::Value::Dict message;
+  message.Set("type", "beep");
   SendMessage(std::move(message));
 }
 
@@ -321,13 +321,13 @@ void PdfViewPluginBase::Email(const std::string& to,
                               const std::string& bcc,
                               const std::string& subject,
                               const std::string& body) {
-  base::Value message(base::Value::Type::DICTIONARY);
-  message.SetStringKey("type", "email");
-  message.SetStringKey("to", net::EscapeUrlEncodedData(to, false));
-  message.SetStringKey("cc", net::EscapeUrlEncodedData(cc, false));
-  message.SetStringKey("bcc", net::EscapeUrlEncodedData(bcc, false));
-  message.SetStringKey("subject", net::EscapeUrlEncodedData(subject, false));
-  message.SetStringKey("body", net::EscapeUrlEncodedData(body, false));
+  base::Value::Dict message;
+  message.Set("type", "email");
+  message.Set("to", net::EscapeUrlEncodedData(to, false));
+  message.Set("cc", net::EscapeUrlEncodedData(cc, false));
+  message.Set("bcc", net::EscapeUrlEncodedData(bcc, false));
+  message.Set("subject", net::EscapeUrlEncodedData(subject, false));
+  message.Set("body", net::EscapeUrlEncodedData(body, false));
   SendMessage(std::move(message));
 }
 
@@ -454,9 +454,9 @@ void PdfViewPluginBase::DocumentLoadProgress(uint32_t available,
 }
 
 void PdfViewPluginBase::FormFieldFocusChange(PDFEngine::FocusFieldType type) {
-  base::Value message(base::Value::Type::DICTIONARY);
-  message.SetStringKey("type", "formFocusChange");
-  message.SetBoolKey("focused", type != PDFEngine::FocusFieldType::kNoFocus);
+  base::Value::Dict message;
+  message.Set("type", "formFocusChange");
+  message.Set("focused", type != PDFEngine::FocusFieldType::kNoFocus);
   SendMessage(std::move(message));
 
   SetFormTextFieldInFocus(type == PDFEngine::FocusFieldType::kText);
@@ -471,9 +471,9 @@ SkColor PdfViewPluginBase::GetBackgroundColor() {
 }
 
 void PdfViewPluginBase::SetIsSelecting(bool is_selecting) {
-  base::Value message(base::Value::Type::DICTIONARY);
-  message.SetStringKey("type", "setIsSelecting");
-  message.SetBoolKey("isSelecting", is_selecting);
+  base::Value::Dict message;
+  message.Set("type", "setIsSelecting");
+  message.Set("isSelecting", is_selecting);
   SendMessage(std::move(message));
 }
 
@@ -503,15 +503,15 @@ void PdfViewPluginBase::EnteredEditMode() {
   edit_mode_ = true;
   SetPluginCanSave(true);
 
-  base::Value message(base::Value::Type::DICTIONARY);
-  message.SetStringKey("type", "setIsEditing");
+  base::Value::Dict message;
+  message.Set("type", "setIsEditing");
   SendMessage(std::move(message));
 }
 
 void PdfViewPluginBase::DocumentFocusChanged(bool document_has_focus) {
-  base::Value message(base::Value::Type::DICTIONARY);
-  message.SetStringKey("type", "documentFocusChanged");
-  message.SetBoolKey("hasFocus", document_has_focus);
+  base::Value::Dict message;
+  message.Set("type", "documentFocusChanged");
+  message.Set("hasFocus", document_has_focus);
   SendMessage(std::move(message));
 }
 
@@ -585,13 +585,13 @@ void PdfViewPluginBase::HandleMessage(const base::Value::Dict& message) {
 void PdfViewPluginBase::SaveToBuffer(const std::string& token) {
   engine()->KillFormFocus();
 
-  base::Value message(base::Value::Type::DICTIONARY);
-  message.SetStringKey("type", "saveData");
-  message.SetStringKey("token", token);
-  message.SetStringKey("fileName", GetFileNameForSaveFromUrl(url_));
+  base::Value::Dict message;
+  message.Set("type", "saveData");
+  message.Set("token", token);
+  message.Set("fileName", GetFileNameForSaveFromUrl(url_));
 
   // Expose `edit_mode_` state for integration testing.
-  message.SetBoolKey("editModeForTesting", edit_mode_);
+  message.Set("editModeForTesting", edit_mode_);
 
   base::Value data_to_save;
   if (edit_mode_) {
@@ -611,14 +611,14 @@ void PdfViewPluginBase::SaveToBuffer(const std::string& token) {
 #endif  // BUILDFLAG(ENABLE_INK)
   }
 
-  message.SetKey("dataToSave", std::move(data_to_save));
+  message.Set("dataToSave", std::move(data_to_save));
   SendMessage(std::move(message));
 }
 
 void PdfViewPluginBase::ConsumeSaveToken(const std::string& token) {
-  base::Value message(base::Value::Type::DICTIONARY);
-  message.SetStringKey("type", "consumeSaveToken");
-  message.SetStringKey("token", token);
+  base::Value::Dict message;
+  message.Set("type", "consumeSaveToken");
+  message.Set("token", token);
   SendMessage(std::move(message));
 }
 
@@ -626,15 +626,15 @@ void PdfViewPluginBase::SendLoadingProgress(double percentage) {
   DCHECK(percentage == -1 || (percentage >= 0 && percentage <= 100));
   last_progress_sent_ = percentage;
 
-  base::Value message(base::Value::Type::DICTIONARY);
-  message.SetStringKey("type", "loadProgress");
-  message.SetDoubleKey("progress", percentage);
+  base::Value::Dict message;
+  message.Set("type", "loadProgress");
+  message.Set("progress", percentage);
   SendMessage(std::move(message));
 }
 
 void PdfViewPluginBase::SendPrintPreviewLoadedNotification() {
-  base::Value message(base::Value::Type::DICTIONARY);
-  message.SetStringKey("type", "printPreviewLoaded");
+  base::Value::Dict message;
+  message.Set("type", "printPreviewLoaded");
   SendMessage(std::move(message));
 }
 
@@ -1053,8 +1053,9 @@ void PdfViewPluginBase::HandleGetNamedDestinationMessage(
                               ? base::checked_cast<int>(named_destination->page)
                               : -1;
 
-  base::Value reply = PrepareReplyMessage("getNamedDestinationReply", message);
-  reply.SetIntKey("pageNumber", page_number);
+  base::Value::Dict reply =
+      PrepareReplyMessage("getNamedDestinationReply", message);
+  reply.Set("pageNumber", page_number);
 
   if (named_destination.has_value() && !named_destination->view.empty()) {
     std::ostringstream view_stream;
@@ -1066,7 +1067,7 @@ void PdfViewPluginBase::HandleGetNamedDestinationMessage(
       view_stream << "," << named_destination->xyz_params;
     }
 
-    reply.SetStringKey("namedDestinationView", view_stream.str());
+    reply.Set("namedDestinationView", view_stream.str());
   }
 
   SendMessage(std::move(reply));
@@ -1084,15 +1085,16 @@ void PdfViewPluginBase::HandleGetSelectedTextMessage(
   std::string selected_text;
   base::RemoveChars(engine()->GetSelectedText(), "\r", &selected_text);
 
-  base::Value reply = PrepareReplyMessage("getSelectedTextReply", message);
-  reply.SetStringKey("selectedText", selected_text);
+  base::Value::Dict reply =
+      PrepareReplyMessage("getSelectedTextReply", message);
+  reply.Set("selectedText", selected_text);
   SendMessage(std::move(reply));
 }
 
 void PdfViewPluginBase::HandleGetThumbnailMessage(
     const base::Value::Dict& message) {
   const int page_index = message.FindInt("page").value();
-  base::Value reply = PrepareReplyMessage("getThumbnailReply", message);
+  base::Value::Dict reply = PrepareReplyMessage("getThumbnailReply", message);
 
   engine()->RequestThumbnail(page_index, device_scale_,
                              base::BindOnce(&PdfViewPluginBase::SendThumbnail,
@@ -1210,8 +1212,8 @@ void PdfViewPluginBase::HandleSaveAttachmentMessage(
   base::Value data_to_save(
       IsSaveDataSizeValid(data.size()) ? data : std::vector<uint8_t>());
 
-  base::Value reply = PrepareReplyMessage("saveAttachmentReply", message);
-  reply.SetKey("dataToSave", std::move(data_to_save));
+  base::Value::Dict reply = PrepareReplyMessage("saveAttachmentReply", message);
+  reply.Set("dataToSave", std::move(data_to_save));
   SendMessage(std::move(reply));
 }
 
@@ -1476,13 +1478,14 @@ void PdfViewPluginBase::ClearDeferredInvalidates() {
   deferred_invalidates_.clear();
 }
 
-void PdfViewPluginBase::SendThumbnail(base::Value reply, Thumbnail thumbnail) {
-  DCHECK_EQ(*reply.FindStringKey("type"), "getThumbnailReply");
-  DCHECK(reply.FindStringKey("messageId"));
+void PdfViewPluginBase::SendThumbnail(base::Value::Dict reply,
+                                      Thumbnail thumbnail) {
+  DCHECK_EQ(*reply.FindString("type"), "getThumbnailReply");
+  DCHECK(reply.FindString("messageId"));
 
-  reply.SetKey("imageData", base::Value(thumbnail.TakeData()));
-  reply.SetIntKey("width", thumbnail.image_size().width());
-  reply.SetIntKey("height", thumbnail.image_size().height());
+  reply.Set("imageData", thumbnail.TakeData());
+  reply.Set("width", thumbnail.image_size().width());
+  reply.Set("height", thumbnail.image_size().height());
   SendMessage(std::move(reply));
 }
 

pdf/pdf_view_plugin_base.h

@@ -235,7 +235,7 @@ class PdfViewPluginBase : public PDFEngine::Client,
   // Enqueues a "message" event carrying `message` to the embedder. Messages are
   // guaranteed to be received in the order that they are sent. This method is
   // non-blocking.
-  virtual void SendMessage(base::Value message) = 0;
+  virtual void SendMessage(base::Value::Dict message) = 0;
 
   // Invokes the "SaveAs" dialog.
   virtual void SaveAs() = 0;
@@ -458,7 +458,7 @@ class PdfViewPluginBase : public PDFEngine::Client,
   void ClearDeferredInvalidates();
 
   // Sends the thumbnail image data.
-  void SendThumbnail(base::Value reply, Thumbnail thumbnail);
+  void SendThumbnail(base::Value::Dict reply, Thumbnail thumbnail);
 
   // Starts loading accessibility information.
   void LoadAccessibility();

pdf/pdf_view_plugin_base_unittest.cc

@@ -142,8 +142,8 @@ class FakePdfViewPluginBase : public PdfViewPluginBase {
 
   MOCK_METHOD(void, OnDocumentLoadComplete, (), (override));
 
-  void SendMessage(base::Value message) override {
-    sent_messages_.push_back(std::move(message));
+  void SendMessage(base::Value::Dict message) override {
+    sent_messages_.push_back(base::Value(std::move(message)));
   }
 
   MOCK_METHOD(void, SaveAs, (), (override));
@@ -202,10 +202,10 @@ class FakePdfViewPluginBase : public PdfViewPluginBase {
 };
 
 base::Value CreateExpectedFormTextFieldFocusChangeResponse() {
-  base::Value message(base::Value::Type::DICTIONARY);
-  message.SetStringKey("type", "formFocusChange");
-  message.SetBoolKey("focused", false);
-  return message;
+  base::Value::Dict message;
+  message.Set("type", "formFocusChange");
+  message.Set("focused", false);
+  return base::Value(std::move(message));
 }
 
 base::Value::Dict CreateSaveRequestMessage(
@@ -220,21 +220,21 @@ base::Value::Dict CreateSaveRequestMessage(
 
 base::Value CreateExpectedSaveToBufferResponse(const std::string& token,
                                                bool edit_mode) {
-  base::Value expected_response(base::Value::Type::DICTIONARY);
-  expected_response.SetStringKey("type", "saveData");
-  expected_response.SetStringKey("token", token);
-  expected_response.SetStringKey("fileName", kDefaultDownloadFileName);
-  expected_response.SetBoolKey("editModeForTesting", edit_mode);
-  expected_response.SetKey(
+  base::Value::Dict expected_response;
+  expected_response.Set("type", "saveData");
+  expected_response.Set("token", token);
+  expected_response.Set("fileName", kDefaultDownloadFileName);
+  expected_response.Set("editModeForTesting", edit_mode);
+  expected_response.Set(
       "dataToSave", base::Value(base::make_span(TestPDFiumEngine::kSaveData)));
-  return expected_response;
+  return base::Value(std::move(expected_response));
 }
 
 base::Value CreateExpectedSaveToFileResponse(const std::string& token) {
-  base::Value expected_response(base::Value::Type::DICTIONARY);
-  expected_response.SetStringKey("type", "consumeSaveToken");
-  expected_response.SetStringKey("token", token);
-  return expected_response;
+  base::Value::Dict expected_response;
+  expected_response.Set("type", "consumeSaveToken");
+  expected_response.Set("token", token);
+  return base::Value(std::move(expected_response));
 }
 
 }  // namespace
@@ -599,12 +599,13 @@ TEST_F(PdfViewPluginBaseTest, EnteredEditMode) {
   EXPECT_CALL(fake_plugin_, SetPluginCanSave(true));
   fake_plugin_.EnteredEditMode();
 
-  base::Value expected_response(base::Value::Type::DICTIONARY);
-  expected_response.SetStringKey("type", "setIsEditing");
+  base::Value::Dict expected_response;
+  expected_response.Set("type", "setIsEditing");
 
   EXPECT_TRUE(fake_plugin_.edit_mode_for_testing());
   ASSERT_EQ(1u, fake_plugin_.sent_messages().size());
-  EXPECT_EQ(expected_response, fake_plugin_.sent_messages()[0]);
+  EXPECT_EQ(base::Value(std::move(expected_response)),
+            fake_plugin_.sent_messages()[0]);
 }
 
 using PdfViewPluginBaseSaveTest = PdfViewPluginBaseWithEngineTest;

pdf/pdf_view_web_plugin.cc

@@ -204,7 +204,7 @@ class BlinkContainerWrapper final : public PdfViewWebPlugin::ContainerWrapper {
     return GetFrame()->GetScrollOffset();
   }
 
-  void PostMessage(base::Value message) override {
+  void PostMessage(base::Value::Dict message) override {
     post_message_sender_.Post(std::move(message));
   }
 
@@ -385,10 +385,10 @@ bool PdfViewWebPlugin::InitializeCommon(
 }
 
 void PdfViewWebPlugin::SendSetSmoothScrolling() {
-  base::Value message(base::Value::Type::DICTIONARY);
-  message.SetStringKey("type", "setSmoothScrolling");
-  message.SetBoolKey("smoothScrolling",
-                     blink::Platform::Current()->IsScrollAnimatorEnabled());
+  base::Value::Dict message;
+  message.Set("type", "setSmoothScrolling");
+  message.Set("smoothScrolling",
+              blink::Platform::Current()->IsScrollAnimatorEnabled());
   SendMessage(std::move(message));
 }
 
@@ -940,7 +940,7 @@ void PdfViewWebPlugin::OnDocumentLoadComplete() {
   SendMetadata();
 }
 
-void PdfViewWebPlugin::SendMessage(base::Value message) {
+void PdfViewWebPlugin::SendMessage(base::Value::Dict message) {
   container_wrapper_->PostMessage(std::move(message));
 }
 
@@ -1187,7 +1187,7 @@ void PdfViewWebPlugin::SendAttachments() {
   if (attachment_infos.empty())
     return;
 
-  base::Value attachments(base::Value::Type::LIST);
+  base::Value::List attachments;
   for (const DocumentAttachmentInfo& attachment_info : attachment_infos) {
     // Send `size` as -1 to indicate that the attachment is too large to be
     // downloaded.
@@ -1195,80 +1195,79 @@ void PdfViewWebPlugin::SendAttachments() {
                          ? static_cast<int>(attachment_info.size_bytes)
                          : -1;
 
-    base::Value attachment(base::Value::Type::DICTIONARY);
-    attachment.SetStringKey("name", attachment_info.name);
-    attachment.SetIntKey("size", size);
-    attachment.SetBoolKey("readable", attachment_info.is_readable);
+    base::Value::Dict attachment;
+    attachment.Set("name", attachment_info.name);
+    attachment.Set("size", size);
+    attachment.Set("readable", attachment_info.is_readable);
     attachments.Append(std::move(attachment));
   }
 
-  base::Value message(base::Value::Type::DICTIONARY);
-  message.SetStringKey("type", "attachments");
-  message.SetKey("attachmentsData", std::move(attachments));
+  base::Value::Dict message;
+  message.Set("type", "attachments");
+  message.Set("attachmentsData", std::move(attachments));
   SendMessage(std::move(message));
 }
 
 void PdfViewWebPlugin::SendBookmarks() {
-  base::Value bookmarks = engine()->GetBookmarks();
-  if (bookmarks.GetListDeprecated().empty())
+  base::Value::List bookmarks = engine()->GetBookmarks();
+  if (bookmarks.empty())
     return;
 
-  base::Value message(base::Value::Type::DICTIONARY);
-  message.SetStringKey("type", "bookmarks");
-  message.SetKey("bookmarksData", std::move(bookmarks));
+  base::Value::Dict message;
+  message.Set("type", "bookmarks");
+  message.Set("bookmarksData", std::move(bookmarks));
   SendMessage(std::move(message));
 }
 
 void PdfViewWebPlugin::SendMetadata() {
-  base::Value metadata(base::Value::Type::DICTIONARY);
+  base::Value::Dict metadata;
   const DocumentMetadata& document_metadata = engine()->GetDocumentMetadata();
 
   const std::string version = FormatPdfVersion(document_metadata.version);
   if (!version.empty())
-    metadata.SetStringKey("version", version);
+    metadata.Set("version", version);
 
-  metadata.SetStringKey("fileSize",
-                        ui::FormatBytes(document_metadata.size_bytes));
+  metadata.Set("fileSize", ui::FormatBytes(document_metadata.size_bytes));
 
-  metadata.SetBoolKey("linearized", document_metadata.linearized);
+  metadata.Set("linearized", document_metadata.linearized);
 
   if (!document_metadata.title.empty())
-    metadata.SetStringKey("title", document_metadata.title);
+    metadata.Set("title", document_metadata.title);
 
   if (!document_metadata.author.empty())
-    metadata.SetStringKey("author", document_metadata.author);
+    metadata.Set("author", document_metadata.author);
 
   if (!document_metadata.subject.empty())
-    metadata.SetStringKey("subject", document_metadata.subject);
+    metadata.Set("subject", document_metadata.subject);
 
   if (!document_metadata.keywords.empty())
-    metadata.SetStringKey("keywords", document_metadata.keywords);
+    metadata.Set("keywords", document_metadata.keywords);
 
   if (!document_metadata.creator.empty())
-    metadata.SetStringKey("creator", document_metadata.creator);
+    metadata.Set("creator", document_metadata.creator);
 
   if (!document_metadata.producer.empty())
-    metadata.SetStringKey("producer", document_metadata.producer);
+    metadata.Set("producer", document_metadata.producer);
 
   if (!document_metadata.creation_date.is_null()) {
-    metadata.SetStringKey("creationDate", base::TimeFormatShortDateAndTime(
-                                              document_metadata.creation_date));
+    metadata.Set("creationDate", base::TimeFormatShortDateAndTime(
+                                     document_metadata.creation_date));
   }
 
   if (!document_metadata.mod_date.is_null()) {
-    metadata.SetStringKey("modDate", base::TimeFormatShortDateAndTime(
-                                         document_metadata.mod_date));
+    metadata.Set("modDate",
+                 base::TimeFormatShortDateAndTime(document_metadata.mod_date));
   }
 
-  metadata.SetStringKey("pageSize",
-                        FormatPageSize(engine()->GetUniformPageSizePoints()));
+  metadata.Set("pageSize",
+               FormatPageSize(engine()->GetUniformPageSizePoints()));
 
-  metadata.SetBoolKey("canSerializeDocument",
-                      IsSaveDataSizeValid(engine()->GetLoadedByteSize()));
+  metadata.Set("canSerializeDocument",
+               IsSaveDataSizeValid(engine()->GetLoadedByteSize()));
 
-  base::Value message(base::Value::Type::DICTIONARY);
-  message.SetStringKey("type", "metadata");
-  message.SetKey("metadataData", std::move(metadata));
+  base::Value::Dict message;
+  message.Set("type", "metadata");
+  message.Set("metadataData", std::move(metadata));
   SendMessage(std::move(message));
 }
 

pdf/pdf_view_web_plugin.h

@@ -97,7 +97,7 @@ class PdfViewWebPlugin final : public PdfViewPluginBase,
     virtual gfx::PointF GetScrollPosition() = 0;
 
     // Enqueues a "message" event carrying `message` to the plugin embedder.
-    virtual void PostMessage(base::Value message) = 0;
+    virtual void PostMessage(base::Value::Dict message) = 0;
 
     // Tells the embedder to allow the plugin to handle find requests.
     virtual void UsePluginAsFindHandler() = 0;
@@ -301,7 +301,7 @@ class PdfViewWebPlugin final : public PdfViewPluginBase,
   base::WeakPtr<PdfViewPluginBase> GetWeakPtr() override;
   std::unique_ptr<UrlLoader> CreateUrlLoaderInternal() override;
   void OnDocumentLoadComplete() override;
-  void SendMessage(base::Value message) override;
+  void SendMessage(base::Value::Dict message) override;
   void SaveAs() override;
   void InitImageData(const gfx::Size& size) override;
   void SetFormTextFieldInFocus(bool in_focus) override;

pdf/pdf_view_web_plugin_unittest.cc

@@ -174,7 +174,7 @@ class FakeContainerWrapper : public PdfViewWebPlugin::ContainerWrapper {
 
   MOCK_METHOD(gfx::PointF, GetScrollPosition, (), (override));
 
-  MOCK_METHOD(void, PostMessage, (base::Value), (override));
+  MOCK_METHOD(void, PostMessage, (base::Value::Dict), (override));
 
   MOCK_METHOD(void, UsePluginAsFindHandler, (), (override));
 
@@ -893,22 +893,22 @@ class PdfViewWebPluginWithoutDocInfoTest : public PdfViewWebPluginTest {
     return std::make_unique<NiceMock<MockUrlLoader>>();
   }
 
-  static base::Value CreateExpectedNoMetadataResponse() {
-    base::Value metadata(base::Value::Type::DICTIONARY);
-    metadata.SetStringKey("fileSize", "0 B");
-    metadata.SetBoolKey("linearized", false);
-    metadata.SetStringKey("pageSize", "Varies");
-    metadata.SetBoolKey("canSerializeDocument", true);
+  static base::Value::Dict CreateExpectedNoMetadataResponse() {
+    base::Value::Dict metadata;
+    metadata.Set("fileSize", "0 B");
+    metadata.Set("linearized", false);
+    metadata.Set("pageSize", "Varies");
+    metadata.Set("canSerializeDocument", true);
 
-    base::Value message(base::Value::Type::DICTIONARY);
-    message.SetStringKey("type", "metadata");
-    message.SetKey("metadataData", std::move(metadata));
+    base::Value::Dict message;
+    message.Set("type", "metadata");
+    message.Set("metadataData", std::move(metadata));
     return message;
   }
 };
 
 TEST_F(PdfViewWebPluginWithoutDocInfoTest, DocumentLoadCompletePostMessages) {
-  const base::Value expect_metadata = CreateExpectedNoMetadataResponse();
+  const base::Value::Dict expect_metadata = CreateExpectedNoMetadataResponse();
   EXPECT_CALL(*wrapper_ptr_, PostMessage);
   EXPECT_CALL(*wrapper_ptr_, PostMessage(Eq(std::ref(expect_metadata))));
   plugin_->DocumentLoadComplete();
@@ -924,28 +924,28 @@ class PdfViewWebPluginWithDocInfoTest : public PdfViewWebPluginTest {
       InitializeDocumentMetadata();
     }
 
-    base::Value GetBookmarks() override {
+    base::Value::List GetBookmarks() override {
       // Create `bookmark1` which navigates to an in-doc position. This bookmark
       // will be in the top-level bookmark list.
-      base::Value bookmark1(base::Value::Type::DICTIONARY);
-      bookmark1.SetStringKey("title", "Bookmark 1");
-      bookmark1.SetIntKey("page", 2);
-      bookmark1.SetIntKey("x", 10);
-      bookmark1.SetIntKey("y", 20);
-      bookmark1.SetDoubleKey("zoom", 2.0);
+      base::Value::Dict bookmark1;
+      bookmark1.Set("title", "Bookmark 1");
+      bookmark1.Set("page", 2);
+      bookmark1.Set("x", 10);
+      bookmark1.Set("y", 20);
+      bookmark1.Set("zoom", 2.0);
 
       // Create `bookmark2` which navigates to a web page. This bookmark will be
       // a child of `bookmark1`.
-      base::Value bookmark2(base::Value::Type::DICTIONARY);
-      bookmark2.SetStringKey("title", "Bookmark 2");
-      bookmark2.SetStringKey("uri", "test.com");
+      base::Value::Dict bookmark2;
+      bookmark2.Set("title", "Bookmark 2");
+      bookmark2.Set("uri", "test.com");
 
-      base::Value children_of_bookmark1(base::Value::Type::LIST);
+      base::Value::List children_of_bookmark1;
       children_of_bookmark1.Append(std::move(bookmark2));
-      bookmark1.SetKey("children", std::move(children_of_bookmark1));
+      bookmark1.Set("children", std::move(children_of_bookmark1));
 
       // Create the top-level bookmark list.
-      base::Value bookmarks(base::Value::Type::LIST);
+      base::Value::List bookmarks;
       bookmarks.Append(std::move(bookmark1));
       return bookmarks;
     }
@@ -1004,72 +1004,74 @@ class PdfViewWebPluginWithDocInfoTest : public PdfViewWebPluginTest {
     return std::make_unique<NiceMock<MockUrlLoader>>();
   }
 
-  static base::Value CreateExpectedAttachmentsResponse() {
-    base::Value attachments(base::Value::Type::LIST);
+  static base::Value::Dict CreateExpectedAttachmentsResponse() {
+    base::Value::List attachments;
     {
-      base::Value attachment(base::Value::Type::DICTIONARY);
-      attachment.SetStringKey("name", "attachment1.txt");
-      attachment.SetIntKey("size", 13);
-      attachment.SetBoolKey("readable", true);
+      base::Value::Dict attachment;
+      attachment.Set("name", "attachment1.txt");
+      attachment.Set("size", 13);
+      attachment.Set("readable", true);
       attachments.Append(std::move(attachment));
     }
     {
-      base::Value attachment(base::Value::Type::DICTIONARY);
-      attachment.SetStringKey("name", "attachment2.pdf");
-      attachment.SetIntKey("size", 0);
-      attachment.SetBoolKey("readable", false);
+      base::Value::Dict attachment;
+      attachment.Set("name", "attachment2.pdf");
+      attachment.Set("size", 0);
+      attachment.Set("readable", false);
       attachments.Append(std::move(attachment));
     }
     {
-      base::Value attachment(base::Value::Type::DICTIONARY);
-      attachment.SetStringKey("name", "attachment3.mov");
-      attachment.SetIntKey("size", -1);
-      attachment.SetBoolKey("readable", true);
+      base::Value::Dict attachment;
+      attachment.Set("name", "attachment3.mov");
+      attachment.Set("size", -1);
+      attachment.Set("readable", true);
       attachments.Append(std::move(attachment));
     }
 
-    base::Value message(base::Value::Type::DICTIONARY);
-    message.SetStringKey("type", "attachments");
-    message.SetKey("attachmentsData", std::move(attachments));
+    base::Value::Dict message;
+    message.Set("type", "attachments");
+    message.Set("attachmentsData", std::move(attachments));
     return message;
   }
 
-  static base::Value CreateExpectedBookmarksResponse(base::Value bookmarks) {
-    base::Value message(base::Value::Type::DICTIONARY);
-    message.SetStringKey("type", "bookmarks");
-    message.SetKey("bookmarksData", std::move(bookmarks));
+  static base::Value::Dict CreateExpectedBookmarksResponse(
+      base::Value::List bookmarks) {
+    base::Value::Dict message;
+    message.Set("type", "bookmarks");
+    message.Set("bookmarksData", std::move(bookmarks));
     return message;
   }
 
-  static base::Value CreateExpectedMetadataResponse() {
-    base::Value metadata(base::Value::Type::DICTIONARY);
-    metadata.SetStringKey("version", "1.7");
-    metadata.SetStringKey("fileSize", "13 B");
-    metadata.SetBoolKey("linearized", true);
+  static base::Value::Dict CreateExpectedMetadataResponse() {
+    base::Value::Dict metadata;
+    metadata.Set("version", "1.7");
+    metadata.Set("fileSize", "13 B");
+    metadata.Set("linearized", true);
 
-    metadata.SetStringKey("title", "Title");
-    metadata.SetStringKey("author", "Author");
-    metadata.SetStringKey("subject", "Subject");
-    metadata.SetStringKey("keywords", "Keywords");
-    metadata.SetStringKey("creator", "Creator");
-    metadata.SetStringKey("producer", "Producer");
-    metadata.SetStringKey("creationDate", "5/4/21, 4:12:13 AM");
-    metadata.SetStringKey("modDate", "6/4/21, 8:16:17 AM");
-    metadata.SetStringKey("pageSize", "13.89 × 16.67 in (portrait)");
-    metadata.SetBoolKey("canSerializeDocument", true);
+    metadata.Set("title", "Title");
+    metadata.Set("author", "Author");
+    metadata.Set("subject", "Subject");
+    metadata.Set("keywords", "Keywords");
+    metadata.Set("creator", "Creator");
+    metadata.Set("producer", "Producer");
+    metadata.Set("creationDate", "5/4/21, 4:12:13 AM");
+    metadata.Set("modDate", "6/4/21, 8:16:17 AM");
+    metadata.Set("pageSize", "13.89 × 16.67 in (portrait)");
+    metadata.Set("canSerializeDocument", true);
 
-    base::Value message(base::Value::Type::DICTIONARY);
-    message.SetStringKey("type", "metadata");
-    message.SetKey("metadataData", std::move(metadata));
+    base::Value::Dict message;
+    message.Set("type", "metadata");
+    message.Set("metadataData", std::move(metadata));
     return message;
   }
 };
 
 TEST_F(PdfViewWebPluginWithDocInfoTest, DocumentLoadCompletePostMessages) {
-  const base::Value expect_attachments = CreateExpectedAttachmentsResponse();
-  const base::Value expect_bookmarks =
+  const base::Value::Dict expect_attachments =
+      CreateExpectedAttachmentsResponse();
+  const base::Value::Dict expect_bookmarks =
       CreateExpectedBookmarksResponse(engine_ptr_->GetBookmarks());
-  const base::Value expect_metadata = CreateExpectedMetadataResponse();
+  const base::Value::Dict expect_metadata = CreateExpectedMetadataResponse();
   EXPECT_CALL(*wrapper_ptr_, PostMessage);
   EXPECT_CALL(*wrapper_ptr_, PostMessage(Eq(std::ref(expect_attachments))));
   EXPECT_CALL(*wrapper_ptr_, PostMessage(Eq(std::ref(expect_bookmarks))));

pdf/pdfium/pdfium_engine.cc

@@ -2354,29 +2354,27 @@ int PDFiumEngine::GetNumberOfPages() const {
   return pages_.size();
 }
 
-base::Value PDFiumEngine::GetBookmarks() {
-  base::Value dict = TraverseBookmarks(nullptr, 0);
-  DCHECK(dict.is_dict());
+base::Value::List PDFiumEngine::GetBookmarks() {
+  base::Value::Dict dict = TraverseBookmarks(nullptr, 0);
   // The root bookmark contains no useful information.
-  base::Value* children = dict.FindListKey("children");
-  DCHECK(children);
+  base::Value::List* children = dict.FindList("children");
   return std::move(*children);
 }
 
-base::Value PDFiumEngine::TraverseBookmarks(FPDF_BOOKMARK bookmark,
-                                            unsigned int depth) {
-  base::Value dict(base::Value::Type::DICTIONARY);
+base::Value::Dict PDFiumEngine::TraverseBookmarks(FPDF_BOOKMARK bookmark,
+                                                  unsigned int depth) {
+  base::Value::Dict dict;
   std::u16string title = CallPDFiumWideStringBufferApi(
       base::BindRepeating(&FPDFBookmark_GetTitle, bookmark),
       /*check_expected_size=*/true);
-  dict.SetStringKey("title", title);
+  dict.Set("title", title);
 
   FPDF_DEST dest = FPDFBookmark_GetDest(doc(), bookmark);
   // Some bookmarks don't have a page to select.
   if (dest) {
     int page_index = FPDFDest_GetDestPageIndex(doc(), dest);
     if (PageIndexInBounds(page_index)) {
-      dict.SetIntKey("page", page_index);
+      dict.Set("page", page_index);
 
       absl::optional<float> x;
       absl::optional<float> y;
@@ -2384,11 +2382,11 @@ base::Value PDFiumEngine::TraverseBookmarks(FPDF_BOOKMARK bookmark,
       pages_[page_index]->GetPageDestinationTarget(dest, &x, &y, &zoom);
 
       if (x)
-        dict.SetIntKey("x", static_cast<int>(x.value()));
+        dict.Set("x", static_cast<int>(x.value()));
       if (y)
-        dict.SetIntKey("y", static_cast<int>(y.value()));
+        dict.Set("y", static_cast<int>(y.value()));
       if (zoom)
-        dict.SetDoubleKey("zoom", zoom.value());
+        dict.Set("zoom", static_cast<double>(zoom.value()));
     }
   } else {
     // Extract URI for bookmarks linking to an external page.
@@ -2397,10 +2395,10 @@ base::Value PDFiumEngine::TraverseBookmarks(FPDF_BOOKMARK bookmark,
         base::BindRepeating(&FPDFAction_GetURIPath, doc(), action),
         /*check_expected_size=*/true);
     if (!uri.empty())
-      dict.SetStringKey("uri", uri);
+      dict.Set("uri", uri);
   }
 
-  base::Value children(base::Value::Type::LIST);
+  base::Value::List children;
 
   // Don't trust PDFium to handle circular bookmarks.
   constexpr unsigned int kMaxDepth = 128;
@@ -2417,7 +2415,7 @@ base::Value PDFiumEngine::TraverseBookmarks(FPDF_BOOKMARK bookmark,
       children.Append(TraverseBookmarks(child_bookmark, depth + 1));
     }
   }
-  dict.SetKey("children", std::move(children));
+  dict.Set("children", std::move(children));
   return dict;
 }
 

pdf/pdfium/pdfium_engine.h

@@ -136,7 +136,7 @@ class PDFiumEngine : public PDFEngine,
   std::vector<uint8_t> GetAttachmentData(size_t index) override;
   const DocumentMetadata& GetDocumentMetadata() const override;
   int GetNumberOfPages() const override;
-  base::Value GetBookmarks() override;
+  base::Value::List GetBookmarks() override;
   absl::optional<PDFEngine::NamedDestination> GetNamedDestination(
       const std::string& destination) override;
   int GetMostVisiblePage() override;
@@ -575,11 +575,12 @@ class PDFiumEngine : public PDFEngine,
   void KillTouchTimer();
   void HandleLongPress(const blink::WebTouchEvent& event);
 
-  // Returns a base::Value (representing a bookmark), which in turn contains
-  // child base::Value dictionaries (representing the child bookmarks).
-  // If nullptr is passed in as the bookmark then we traverse from the "root".
-  // Note that the "root" bookmark contains no useful information.
-  base::Value TraverseBookmarks(FPDF_BOOKMARK bookmark, unsigned int depth);
+  // Returns a dictionary representing a bookmark, which in turn contains child
+  // dictionaries representing the child bookmarks. If `bookmark` is null, then
+  // this method traverses from the root of the bookmarks tree. Note that the
+  // root bookmark contains no useful information.
+  base::Value::Dict TraverseBookmarks(FPDF_BOOKMARK bookmark,
+                                      unsigned int depth);
 
   void ScrollBasedOnScrollAlignment(
       const gfx::Rect& scroll_rect,

pdf/pdfium/pdfium_engine_exports.cc

@@ -160,23 +160,23 @@ base::Value RecursiveGetStructTree(FPDF_STRUCTELEMENT struct_elem) {
   if (!opt_type)
     return base::Value(base::Value::Type::NONE);
 
-  base::Value result(base::Value::Type::DICTIONARY);
-  result.SetStringKey("type", *opt_type);
+  base::Value::Dict result;
+  result.Set("type", *opt_type);
 
   absl::optional<std::u16string> opt_alt =
       CallPDFiumWideStringBufferApiAndReturnOptional(
           base::BindRepeating(FPDF_StructElement_GetAltText, struct_elem),
           true);
   if (opt_alt)
-    result.SetStringKey("alt", *opt_alt);
+    result.Set("alt", *opt_alt);
 
   absl::optional<std::u16string> opt_lang =
       CallPDFiumWideStringBufferApiAndReturnOptional(
           base::BindRepeating(FPDF_StructElement_GetLang, struct_elem), true);
   if (opt_lang)
-    result.SetStringKey("lang", *opt_lang);
+    result.Set("lang", *opt_lang);
 
-  base::Value children(base::Value::Type::LIST);
+  base::Value::List children;
   for (int i = 0; i < children_count; i++) {
     FPDF_STRUCTELEMENT child_elem =
         FPDF_StructElement_GetChildAtIndex(struct_elem, i);
@@ -189,10 +189,10 @@ base::Value RecursiveGetStructTree(FPDF_STRUCTELEMENT struct_elem) {
   // use "~children" instead of "children" because we pretty-print the
   // result of this as JSON and the keys are sorted; it's much easier to
   // understand when the children are the last key.
-  if (!children.GetListDeprecated().empty())
-    result.SetKey("~children", std::move(children));
+  if (!children.empty())
+    result.Set("~children", std::move(children));
 
-  return result;
+  return base::Value(std::move(result));
 }
 
 }  // namespace

pdf/post_message_sender.cc

@@ -34,7 +34,7 @@ PostMessageSender::~PostMessageSender() = default;
 // When that happens, the body of this method needs to be posted to the main
 // thread as a task because that's where the Blink and V8 interactions need to
 // occur.
-void PostMessageSender::Post(base::Value message) {
+void PostMessageSender::Post(base::Value::Dict message) {
   v8::Isolate::Scope isolate_scope(isolate_);
   v8::HandleScope handle_scope(isolate_);
   v8::Local<v8::Context> context =
@@ -43,7 +43,7 @@ void PostMessageSender::Post(base::Value message) {
   v8::Context::Scope context_scope(context);
 
   v8::Local<v8::Value> converted_message =
-      v8_value_converter_->ToV8Value(message, context);
+      v8_value_converter_->ToV8Value(base::Value(std::move(message)), context);
 
   container_->EnqueueMessageEvent(
       blink::WebSerializedScriptValue::Serialize(isolate_, converted_message));

pdf/post_message_sender.h

@@ -6,12 +6,9 @@
 #define PDF_POST_MESSAGE_SENDER_H_
 
 #include "base/memory/raw_ptr.h"
+#include "base/values.h"
 #include "v8/include/v8-forward.h"
 
-namespace base {
-class Value;
-}  // namespace base
-
 namespace blink {
 class WebPluginContainer;
 }  // namespace blink
@@ -30,7 +27,7 @@ class PostMessageSender final {
   ~PostMessageSender();
 
   // Enqueues a "message" event carrying `message` to the plugin embedder.
-  void Post(base::Value message);
+  void Post(base::Value::Dict message);
 
  private:
   const raw_ptr<V8ValueConverter> v8_value_converter_;

pdf/test/test_pdfium_engine.cc

@@ -49,8 +49,8 @@ int TestPDFiumEngine::GetNumberOfPages() const {
   return static_cast<int>(kPageNumber);
 }
 
-base::Value TestPDFiumEngine::GetBookmarks() {
-  return base::Value(base::Value::Type::LIST);
+base::Value::List TestPDFiumEngine::GetBookmarks() {
+  return base::Value::List();
 }
 
 uint32_t TestPDFiumEngine::GetLoadedByteSize() {

pdf/test/test_pdfium_engine.h

@@ -70,7 +70,7 @@ class TestPDFiumEngine : public PDFiumEngine {
   int GetNumberOfPages() const override;
 
   // Returns an empty bookmark list.
-  base::Value GetBookmarks() override;
+  base::Value::List GetBookmarks() override;
 
   MOCK_METHOD(void, SetGrayscale, (bool), (override));