WebString: makes string16 conversions explicit (part 1: blink, content)

content/renderer/render_widget.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 "content/renderer/render_widget.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/auto_reset.h"
@@ skipping 43 matching lines @@
 #include "content/renderer/render_process.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/render_view_impl.h"
 #include "content/renderer/render_widget_owner_delegate.h"
 #include "content/renderer/renderer_blink_platform_impl.h"
 #include "content/renderer/resizing_mode_selector.h"
 #include "ipc/ipc_message_start.h"
 #include "ipc/ipc_sync_message.h"
 #include "ppapi/features/features.h"
 #include "skia/ext/platform_canvas.h"
+#include "third_party/WebKit/public/platform/FilePathConversion.h"
 #include "third_party/WebKit/public/platform/WebCursorInfo.h"
 #include "third_party/WebKit/public/platform/WebDragData.h"
 #include "third_party/WebKit/public/platform/WebDragOperation.h"
 #include "third_party/WebKit/public/platform/WebPoint.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
 #include "third_party/WebKit/public/platform/WebSize.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/scheduler/renderer/render_widget_scheduling_state.h"
 #include "third_party/WebKit/public/platform/scheduler/renderer/renderer_scheduler.h"
 #include "third_party/WebKit/public/web/WebDeviceEmulationParams.h"
@@ skipping 119 matching lines @@
   return widget;
 }
 
 WebDragData DropMetaDataToWebDragData(
     const std::vector<DropData::Metadata>& drop_meta_data) {
   std::vector<WebDragData::Item> item_list;
   for (const auto& meta_data_item : drop_meta_data) {
     if (meta_data_item.kind == DropData::Kind::STRING) {
       WebDragData::Item item;
       item.storageType = WebDragData::Item::StorageTypeString;
-      item.stringType = meta_data_item.mime_type;
+      item.stringType = WebString::fromUTF16(meta_data_item.mime_type);
       // Have to pass a dummy URL here instead of an empty URL because the
       // DropData received by browser_plugins goes through a round trip:
       // DropData::MetaData --> WebDragData-->DropData. In the end, DropData
       // will contain an empty URL (which means no URL is dragged) if the URL in
       // WebDragData is empty.
       if (base::EqualsASCII(meta_data_item.mime_type,
                             ui::Clipboard::kMimeTypeURIList)) {
         item.stringData = WebString::fromUTF8("about:dragdrop-placeholder");
       }
       item_list.push_back(item);
       continue;
     }
 
     // TODO(hush): crbug.com/584789. Blink needs to support creating a file with
     // just the mimetype. This is needed to drag files to WebView on Android
     // platform.
     if ((meta_data_item.kind == DropData::Kind::FILENAME) &&
         !meta_data_item.filename.empty()) {
       WebDragData::Item item;
       item.storageType = WebDragData::Item::StorageTypeFilename;
-      item.filenameData = meta_data_item.filename.AsUTF16Unsafe();
+      item.filenameData = blink::FilePathToWebString(meta_data_item.filename);
       item_list.push_back(item);
       continue;
     }
 
     if (meta_data_item.kind == DropData::Kind::FILESYSTEMFILE) {
       WebDragData::Item item;
       item.storageType = WebDragData::Item::StorageTypeFileSystemFile;
       item.fileSystemURL = meta_data_item.file_system_url;
       item_list.push_back(item);
       continue;
@@ skipping 11 matching lines @@
 
   // These fields are currently unused when dragging into WebKit.
   DCHECK(drop_data.download_metadata.empty());
   DCHECK(drop_data.file_contents.empty());
   DCHECK(drop_data.file_description_filename.empty());
 
   if (!drop_data.text.is_null()) {
     WebDragData::Item item;
     item.storageType = WebDragData::Item::StorageTypeString;
     item.stringType = WebString::fromUTF8(ui::Clipboard::kMimeTypeText);
-    item.stringData = drop_data.text.string();
+    item.stringData = WebString::fromUTF16(drop_data.text.string());
     item_list.push_back(item);
   }
 
   if (!drop_data.url.is_empty()) {
     WebDragData::Item item;
     item.storageType = WebDragData::Item::StorageTypeString;
     item.stringType = WebString::fromUTF8(ui::Clipboard::kMimeTypeURIList);
     item.stringData = WebString::fromUTF8(drop_data.url.spec());
-    item.title = drop_data.url_title;
+    item.title = WebString::fromUTF16(drop_data.url_title);
     item_list.push_back(item);
   }
 
   if (!drop_data.html.is_null()) {
     WebDragData::Item item;
     item.storageType = WebDragData::Item::StorageTypeString;
     item.stringType = WebString::fromUTF8(ui::Clipboard::kMimeTypeHTML);
-    item.stringData = drop_data.html.string();
+    item.stringData = WebString::fromUTF16(drop_data.html.string());
     item.baseURL = drop_data.html_base_url;
     item_list.push_back(item);
   }
 
   for (std::vector<ui::FileInfo>::const_iterator it =
            drop_data.filenames.begin();
        it != drop_data.filenames.end();
        ++it) {
     WebDragData::Item item;
     item.storageType = WebDragData::Item::StorageTypeFilename;
-    item.filenameData = it->path.AsUTF16Unsafe();
-    item.displayNameData = it->display_name.AsUTF16Unsafe();
+    item.filenameData = blink::FilePathToWebString(it->path);
+    item.displayNameData =
+        blink::FilePathToWebString(base::FilePath(it->display_name));
     item_list.push_back(item);
   }
 
   for (std::vector<DropData::FileSystemFileInfo>::const_iterator it =
            drop_data.file_system_files.begin();
        it != drop_data.file_system_files.end();
        ++it) {
     WebDragData::Item item;
     item.storageType = WebDragData::Item::StorageTypeFileSystemFile;
     item.fileSystemURL = it->url;
     item.fileSystemFileSize = it->size;
     item_list.push_back(item);
   }
 
   for (std::map<base::string16, base::string16>::const_iterator it =
            drop_data.custom_data.begin();
        it != drop_data.custom_data.end();
        ++it) {
     WebDragData::Item item;
     item.storageType = WebDragData::Item::StorageTypeString;
-    item.stringType = it->first;
-    item.stringData = it->second;
+    item.stringType = WebString::fromUTF16(it->first);
+    item.stringData = WebString::fromUTF16(it->second);
     item_list.push_back(item);
   }
 
   WebDragData result;
   result.initialize();
   result.setItems(item_list);
-  result.setFilesystemId(drop_data.filesystem_id);
+  result.setFilesystemId(WebString::fromUTF16(drop_data.filesystem_id));
   return result;
 }
 
 content::RenderWidget::CreateRenderWidgetFunction g_create_render_widget =
     nullptr;
 
 content::RenderWidget::RenderWidgetInitializedCallback
     g_render_widget_initialized = nullptr;
 
 ui::TextInputType ConvertWebTextInputType(blink::WebTextInputType type) {
@@ skipping 1152 matching lines @@
 }
 
 WebRect RenderWidget::viewRect() {
   WebRect rect = view_screen_rect_;
   ScreenRectToEmulatedIfNeeded(&rect);
   return rect;
 }
 
 void RenderWidget::setToolTipText(const blink::WebString& text,
                                   WebTextDirection hint) {
-  Send(new ViewHostMsg_SetTooltipText(routing_id_, text, hint));
+  Send(new ViewHostMsg_SetTooltipText(routing_id_, text.utf16(), hint));
 }
 
 void RenderWidget::setWindowRect(const WebRect& rect_in_screen) {
   WebRect window_rect = rect_in_screen;
   EmulatedToScreenRectIfNeeded(&window_rect);
 
   if (!resizing_mode_selector_->is_synchronous_mode()) {
     if (did_show_) {
       Send(new ViewHostMsg_RequestMove(routing_id_, window_rect));
       SetPendingWindowRect(window_rect);
@@ skipping 34 matching lines @@
         WebRange(replacement_range.start(), replacement_range.length()));
   }
 
   if (!ShouldHandleImeEvent())
     return;
   ImeEventGuard guard(this);
   blink::WebInputMethodController* controller = GetInputMethodController();
   DCHECK(controller);
   if (!controller ||
       !controller->setComposition(
-          text, WebVector<WebCompositionUnderline>(underlines), selection_start,
+          WebString::fromUTF16(text),
+          WebVector<WebCompositionUnderline>(underlines), selection_start,
           selection_end)) {
     // If we failed to set the composition text, then we need to let the browser
     // process to cancel the input method's ongoing composition session, to make
     // sure we are in a consistent state.
     Send(new InputHostMsg_ImeCancelComposition(routing_id()));
   }
   UpdateCompositionInfo(false /* not an immediate request */);
 }
 
 void RenderWidget::OnImeCommitText(const base::string16& text,
                                    const gfx::Range& replacement_range,
                                    int relative_cursor_pos) {
 #if BUILDFLAG(ENABLE_PLUGINS)
   if (focused_pepper_plugin_) {
     focused_pepper_plugin_->render_frame()->OnImeCommitText(
         text, replacement_range, relative_cursor_pos);
     return;
   }
 #endif
   if (replacement_range.IsValid()) {
     GetWebWidget()->applyReplacementRange(
         WebRange(replacement_range.start(), replacement_range.length()));
   }
 
   if (!ShouldHandleImeEvent())
     return;
   ImeEventGuard guard(this);
   input_handler_->set_handling_input_event(true);
   if (auto* controller = GetInputMethodController())
-    controller->commitText(text, relative_cursor_pos);
+    controller->commitText(WebString::fromUTF16(text), relative_cursor_pos);
   input_handler_->set_handling_input_event(false);
   UpdateCompositionInfo(false /* not an immediate request */);
 }
 
 void RenderWidget::OnImeFinishComposingText(bool keep_selection) {
 #if BUILDFLAG(ENABLE_PLUGINS)
   if (focused_pepper_plugin_) {
     focused_pepper_plugin_->render_frame()->OnImeFinishComposingText(
         keep_selection);
     return;
@@ skipping 726 matching lines @@
 blink::WebInputMethodController* RenderWidget::GetInputMethodController()
     const {
   // TODO(ekaramad): Remove this CHECK when GetWebWidget() is
   // always a WebFrameWidget.
   CHECK(GetWebWidget()->isWebFrameWidget());
   return static_cast<blink::WebFrameWidget*>(GetWebWidget())
       ->getActiveWebInputMethodController();
 }
 
 }  // namespace content