Replace string16 with base::string16 in src/webkit

webkit/plugins/ppapi/ppapi_plugin_instance.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 "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 585 matching lines @@
 bool PluginInstance::HandleDocumentLoad(PPB_URLLoader_Impl* loader) {
   if (!document_loader_)
     document_loader_ = loader;
   DCHECK(loader == document_loader_.get());
 
   return PP_ToBool(instance_interface_->HandleDocumentLoad(
       pp_instance(), loader->pp_resource()));
 }
 
 bool PluginInstance::SendCompositionEventToPlugin(PP_InputEvent_Type type,
-                                                  const string16& text) {
+                                                  const base::string16& text) {
   std::vector<WebKit::WebCompositionUnderline> empty;
   return SendCompositionEventWithUnderlineInformationToPlugin(
       type, text, empty, static_cast<int>(text.size()),
       static_cast<int>(text.size()));
 }
 
 bool PluginInstance::SendCompositionEventWithUnderlineInformationToPlugin(
     PP_InputEvent_Type type,
-    const string16& text,
+    const base::string16& text,
     const std::vector<WebKit::WebCompositionUnderline>& underlines,
     int selection_start,
     int selection_end) {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PluginInstance> ref(this);
 
   if (!LoadInputEventInterface())
     return false;
 
   PP_InputEvent_Class event_class = PP_INPUTEVENT_CLASS_IME;
@@ skipping 60 matching lines @@
   return handled;
 }
 
 void PluginInstance::RequestInputEventsHelper(uint32_t event_classes) {
   if (event_classes & PP_INPUTEVENT_CLASS_TOUCH)
     UpdateTouchEventRequest();
   if (event_classes & PP_INPUTEVENT_CLASS_WHEEL)
     container_->setWantsWheelEvents(IsAcceptingWheelEvents());
 }
 
-bool PluginInstance::HandleCompositionStart(const string16& text) {
+bool PluginInstance::HandleCompositionStart(const base::string16& text) {
   return SendCompositionEventToPlugin(PP_INPUTEVENT_TYPE_IME_COMPOSITION_START,
                                       text);
 }
 
 bool PluginInstance::HandleCompositionUpdate(
-    const string16& text,
+    const base::string16& text,
     const std::vector<WebKit::WebCompositionUnderline>& underlines,
     int selection_start,
     int selection_end) {
   return SendCompositionEventWithUnderlineInformationToPlugin(
       PP_INPUTEVENT_TYPE_IME_COMPOSITION_UPDATE,
       text, underlines, selection_start, selection_end);
 }
 
-bool PluginInstance::HandleCompositionEnd(const string16& text) {
+bool PluginInstance::HandleCompositionEnd(const base::string16& text) {
   return SendCompositionEventToPlugin(PP_INPUTEVENT_TYPE_IME_COMPOSITION_END,
                                       text);
 }
 
-bool PluginInstance::HandleTextInput(const string16& text) {
+bool PluginInstance::HandleTextInput(const base::string16& text) {
   return SendCompositionEventToPlugin(PP_INPUTEVENT_TYPE_IME_TEXT,
                                       text);
 }
 
-void PluginInstance::GetSurroundingText(string16* text,
+void PluginInstance::GetSurroundingText(base::string16* text,
                                         ui::Range* range) const {
   std::vector<size_t> offsets;
   offsets.push_back(selection_anchor_);
   offsets.push_back(selection_caret_);
   *text = base::UTF8ToUTF16AndAdjustOffsets(surrounding_text_, &offsets);
-  range->set_start(offsets[0] == string16::npos ? text->size() : offsets[0]);
-  range->set_end(offsets[1] == string16::npos ? text->size() : offsets[1]);
+  range->set_start(offsets[0] == base::string16::npos ? text->size()
+                                                      : offsets[0]);
+  range->set_end(offsets[1] == base::string16::npos ? text->size()
+                                                    : offsets[1]);
 }
 
 bool PluginInstance::IsPluginAcceptingCompositionEvents() const {
   return (filtered_input_event_mask_ & PP_INPUTEVENT_CLASS_IME) ||
       (input_event_mask_ & PP_INPUTEVENT_CLASS_IME);
 }
 
 gfx::Rect PluginInstance::GetCaretBounds() const {
   if (!text_input_caret_set_) {
     // If it is never set by the plugin, use the bottom left corner.
@@ skipping 248 matching lines @@
   plugin_backing_store_rect.Offset(plugin_offset);
   *location = plugin_backing_store_rect;
   clip_page.Offset(plugin_offset);
   *clip = clip_page;
   // The plugin scale factor is inverted, e.g. for a device scale factor of 2x
   // the plugin scale factor is 0.5.
   *scale_factor = 1.0 / scale;
   return true;
 }
 
-string16 PluginInstance::GetSelectedText(bool html) {
+base::string16 PluginInstance::GetSelectedText(bool html) {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PluginInstance> ref(this);
   if (!LoadSelectionInterface())
-    return string16();
+    return base::string16();
 
   PP_Var rv = plugin_selection_interface_->GetSelectedText(pp_instance(),
                                                            PP_FromBool(html));
   StringVar* string = StringVar::FromPPVar(rv);
-  string16 selection;
+  base::string16 selection;
   if (string)
     selection = UTF8ToUTF16(string->value());
   // Release the ref the plugin transfered to us.
   HostGlobals::Get()->GetVarTracker()->ReleaseVar(rv);
   return selection;
 }
 
-string16 PluginInstance::GetLinkAtPosition(const gfx::Point& point) {
+base::string16 PluginInstance::GetLinkAtPosition(const gfx::Point& point) {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PluginInstance> ref(this);
   if (!LoadPdfInterface())
-    return string16();
+    return base::string16();
 
   PP_Point p;
   p.x = point.x();
   p.y = point.y();
   PP_Var rv = plugin_pdf_interface_->GetLinkAtPosition(pp_instance(), p);
   StringVar* string = StringVar::FromPPVar(rv);
-  string16 link;
+  base::string16 link;
   if (string)
     link = UTF8ToUTF16(string->value());
   // Release the ref the plugin transfered to us.
   PpapiGlobals::Get()->GetVarTracker()->ReleaseVar(rv);
   return link;
 }
 
 void PluginInstance::RequestSurroundingText(
     size_t desired_number_of_characters) {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PluginInstance> ref(this);
   if (!LoadTextInputInterface())
     return;
   plugin_textinput_interface_->RequestSurroundingText(
       pp_instance(), desired_number_of_characters);
 }
 
 void PluginInstance::Zoom(double factor, bool text_only) {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PluginInstance> ref(this);
   if (!LoadZoomInterface())
     return;
   plugin_zoom_interface_->Zoom(pp_instance(), factor, PP_FromBool(text_only));
 }
 
-bool PluginInstance::StartFind(const string16& search_text,
+bool PluginInstance::StartFind(const base::string16& search_text,
                                bool case_sensitive,
                                int identifier) {
   // Keep a reference on the stack. See NOTE above.
   scoped_refptr<PluginInstance> ref(this);
   if (!LoadFindInterface())
     return false;
   find_identifier_ = identifier;
   return PP_ToBool(
       plugin_find_interface_->StartFind(
           pp_instance(),
@@ skipping 767 matching lines @@
 
 void PluginInstance::SimulateImeSetCompositionEvent(
     const InputEventData& input_event) {
   std::vector<size_t> offsets;
   offsets.push_back(input_event.composition_selection_start);
   offsets.push_back(input_event.composition_selection_end);
   offsets.insert(offsets.end(),
                  input_event.composition_segment_offsets.begin(),
                  input_event.composition_segment_offsets.end());
 
-  string16 utf16_text =
+  base::string16 utf16_text =
       base::UTF8ToUTF16AndAdjustOffsets(input_event.character_text, &offsets);
 
   std::vector<WebKit::WebCompositionUnderline> underlines;
   for (size_t i = 2; i + 1 < offsets.size(); ++i) {
     WebKit::WebCompositionUnderline underline;
     underline.startOffset = offsets[i];
     underline.endOffset = offsets[i + 1];
     if (input_event.composition_target_segment == static_cast<int32_t>(i - 2))
       underline.thick = true;
     underlines.push_back(underline);
@@ skipping 656 matching lines @@
   screen_size_for_fullscreen_ = gfx::Size();
   WebElement element = container_->element();
   element.setAttribute(WebString::fromUTF8(kWidth), width_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kHeight), height_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kBorder), border_before_fullscreen_);
   element.setAttribute(WebString::fromUTF8(kStyle), style_before_fullscreen_);
 }
 
 }  // namespace ppapi
 }  // namespace webkit