Prefix string16 with base:: in ui/.

ui/base/ime/win/tsf_text_store_unittest.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 "ui/base/ime/win/tsf_text_store.h"
 
 #include <initguid.h>  // for GUID_NULL and GUID_PROP_INPUTSCOPE
 #include <InputScope.h>
 #include <OleCtl.h>
 
@@ skipping 11 matching lines @@
 
 namespace ui {
 namespace {
 
 class MockTextInputClient : public TextInputClient {
  public:
   ~MockTextInputClient() {}
   MOCK_METHOD1(SetCompositionText, void(const ui::CompositionText&));
   MOCK_METHOD0(ConfirmCompositionText, void());
   MOCK_METHOD0(ClearCompositionText, void());
-  MOCK_METHOD1(InsertText, void(const string16&));
+  MOCK_METHOD1(InsertText, void(const base::string16&));
   MOCK_METHOD2(InsertChar, void(char16, int));
   MOCK_CONST_METHOD0(GetAttachedWindow, gfx::NativeWindow());
   MOCK_CONST_METHOD0(GetTextInputType, ui::TextInputType());
   MOCK_CONST_METHOD0(GetTextInputMode, ui::TextInputMode());
   MOCK_CONST_METHOD0(CanComposeInline, bool());
   MOCK_CONST_METHOD0(GetCaretBounds, gfx::Rect());
   MOCK_CONST_METHOD2(GetCompositionCharacterBounds, bool(uint32, gfx::Rect*));
   MOCK_CONST_METHOD0(HasCompositionText, bool());
   MOCK_CONST_METHOD1(GetTextRange, bool(gfx::Range*));
   MOCK_CONST_METHOD1(GetCompositionTextRange, bool(gfx::Range*));
   MOCK_CONST_METHOD1(GetSelectionRange, bool(gfx::Range*));
   MOCK_METHOD1(SetSelectionRange, bool(const gfx::Range&));
   MOCK_METHOD1(DeleteRange, bool(const gfx::Range&));
-  MOCK_CONST_METHOD2(GetTextFromRange, bool(const gfx::Range&, string16*));
+  MOCK_CONST_METHOD2(GetTextFromRange, bool(const gfx::Range&,
+                                            base::string16*));
   MOCK_METHOD0(OnInputMethodChanged, void());
   MOCK_METHOD1(ChangeTextDirectionAndLayoutAlignment,
                bool(base::i18n::TextDirection));
   MOCK_METHOD2(ExtendSelectionAndDelete, void(size_t, size_t));
   MOCK_METHOD1(EnsureCaretInRect, void(const gfx::Rect&));
   MOCK_METHOD0(OnCandidateWindowShown, void());
   MOCK_METHOD0(OnCandidateWindowUpdated, void());
   MOCK_METHOD0(OnCandidateWindowHidden, void());
 };
 
@@ skipping 64 matching lines @@
                                            &text_input_client_);
   }
 
   virtual void TearDown() OVERRIDE {
     EXPECT_EQ(S_OK, text_store_->UnadviseSink(sink_));
     sink_ = NULL;
     text_store_ = NULL;
   }
 
   // Accessors to the internal state of TSFTextStore.
-  string16* string_buffer() { return &text_store_->string_buffer_; }
+  base::string16* string_buffer() { return &text_store_->string_buffer_; }
   size_t* committed_size() { return &text_store_->committed_size_; }
 
   base::win::ScopedCOMInitializer com_initializer_;
   MockTextInputClient text_input_client_;
   scoped_refptr<TSFTextStore> text_store_;
   scoped_refptr<MockStoreACPSink> sink_;
 };
 
 class TSFTextStoreTestCallback {
  public:
   explicit TSFTextStoreTestCallback(TSFTextStore* text_store)
       : text_store_(text_store) {
     CHECK(text_store_);
   }
   virtual ~TSFTextStoreTestCallback() {}
 
  protected:
   // Accessors to the internal state of TSFTextStore.
   bool* edit_flag() { return &text_store_->edit_flag_; }
-  string16* string_buffer() { return &text_store_->string_buffer_; }
+  base::string16* string_buffer() { return &text_store_->string_buffer_; }
   size_t* committed_size() { return &text_store_->committed_size_; }
   gfx::Range* selection() { return &text_store_->selection_; }
   CompositionUnderlines* composition_undelines() {
     return &text_store_->composition_undelines_;
   }
 
-  void SetInternalState(const string16& new_string_buffer,
+  void SetInternalState(const base::string16& new_string_buffer,
                         LONG new_committed_size, LONG new_selection_start,
                         LONG new_selection_end) {
     ASSERT_LE(0, new_committed_size);
     ASSERT_LE(new_committed_size, new_selection_start);
     ASSERT_LE(new_selection_start, new_selection_end);
     ASSERT_LE(new_selection_end, static_cast<LONG>(new_string_buffer.size()));
     *string_buffer() = new_string_buffer;
     *committed_size() = new_committed_size;
     selection()->set_start(new_selection_start);
     selection()->set_end(new_selection_end);
@@ skipping 17 matching lines @@
     selection.acpEnd = acp_end;
     selection.style.ase = TS_AE_NONE;
     selection.style.fInterimChar = 0;
     EXPECT_EQ(expected_result, text_store_->SetSelection(1, &selection));
     if (expected_result == S_OK) {
       GetSelectionTest(acp_start, acp_end);
     }
   }
 
   void SetTextTest(LONG acp_start, LONG acp_end,
-                   const string16& text, HRESULT error_code) {
+                   const base::string16& text, HRESULT error_code) {
     TS_TEXTCHANGE change = {};
     ASSERT_EQ(error_code,
               text_store_->SetText(0, acp_start, acp_end,
                                    text.c_str(), text.size(), &change));
     if (error_code == S_OK) {
       EXPECT_EQ(acp_start, change.acpStart);
       EXPECT_EQ(acp_end, change.acpOldEnd);
       EXPECT_EQ(acp_start + text.size(), change.acpNewEnd);
     }
   }
 
   void GetTextTest(LONG acp_start, LONG acp_end,
-                   const string16& expected_string,
+                   const base::string16& expected_string,
                    LONG expected_next_acp) {
     wchar_t buffer[1024] = {};
     ULONG text_buffer_copied = 0;
     TS_RUNINFO run_info = {};
     ULONG run_info_buffer_copied = 0;
     LONG next_acp = 0;
     ASSERT_EQ(S_OK,
               text_store_->GetText(acp_start, acp_end, buffer, 1024,
                                    &text_buffer_copied,
                                    &run_info, 1, &run_info_buffer_copied,
                                    &next_acp));
     ASSERT_EQ(expected_string.size(), text_buffer_copied);
-    EXPECT_EQ(expected_string, string16(buffer, buffer + text_buffer_copied));
+    EXPECT_EQ(expected_string,
+              base::string16(buffer, buffer + text_buffer_copied));
     EXPECT_EQ(1, run_info_buffer_copied);
     EXPECT_EQ(expected_string.size(), run_info.uCount);
     EXPECT_EQ(TS_RT_PLAIN, run_info.type);
     EXPECT_EQ(expected_next_acp, next_acp);
   }
 
   void GetTextErrorTest(LONG acp_start, LONG acp_end, HRESULT error_code) {
     wchar_t buffer[1024] = {};
     ULONG text_buffer_copied = 0;
     TS_RUNINFO run_info = {};
@@ skipping 308 matching lines @@
     EXPECT_TRUE(HasReadWriteLock());
 
     *edit_flag() = true;
     SetInternalState(L"012345", 6, 6, 6);
     composition_undelines()->clear();
 
     state_ = 2;
     return S_OK;
   }
 
-  void InsertText(const string16& text) {
+  void InsertText(const base::string16& text) {
     EXPECT_EQ(2, state_);
     EXPECT_EQ(L"012345", text);
     state_ = 3;
   }
 
   void SetCompositionText(const ui::CompositionText& composition) {
     EXPECT_EQ(3, state_);
     EXPECT_EQ(L"", composition.text);
     EXPECT_EQ(0, composition.selection.start());
     EXPECT_EQ(0, composition.selection.end());
@@ skipping 488 matching lines @@
     underline.color = SK_ColorBLACK;
     underline.thick = false;
     composition_undelines()->push_back(underline);
 
     *edit_flag() = true;
     *committed_size() = 3;
 
     return S_OK;
   }
 
-  void InsertText2(const string16& text) {
+  void InsertText2(const base::string16& text) {
     EXPECT_EQ(L"axy", text);
   }
 
   void SetCompositionText2(const ui::CompositionText& composition) {
     EXPECT_EQ(L"ZCPc", composition.text);
     EXPECT_EQ(0, composition.selection.start());
     EXPECT_EQ(3, composition.selection.end());
     ASSERT_EQ(2, composition.underlines.size());
     EXPECT_EQ(SK_ColorBLACK, composition.underlines[0].color);
     EXPECT_EQ(0, composition.underlines[0].start_offset);
     EXPECT_EQ(2, composition.underlines[0].end_offset);
     EXPECT_TRUE(composition.underlines[0].thick);
     EXPECT_EQ(SK_ColorBLACK, composition.underlines[1].color);
     EXPECT_EQ(2, composition.underlines[1].start_offset);
     EXPECT_EQ(4, composition.underlines[1].end_offset);
     EXPECT_FALSE(composition.underlines[1].thick);
   }
 
   HRESULT LockGranted3(DWORD flags) {
     GetTextTest(0, -1, L"axyZCPc", 7);
 
     composition_undelines()->clear();
     *edit_flag() = true;
     *committed_size() = 7;
 
     return S_OK;
   }
 
-  void InsertText3(const string16& text) {
+  void InsertText3(const base::string16& text) {
     EXPECT_EQ(L"ZCPc", text);
   }
 
   void SetCompositionText3(const ui::CompositionText& composition) {
     EXPECT_EQ(L"", composition.text);
     EXPECT_EQ(0, composition.selection.start());
     EXPECT_EQ(0, composition.selection.end());
     EXPECT_EQ(0, composition.underlines.size());
   }
 
@@ skipping 193 matching lines @@
     text_store_->SetFocusedTextInputClient(NULL, NULL);
     num_copied = 0xfffffff;
     TS_ATTRVAL buffer[2] = {};
     EXPECT_HRESULT_FAILED(text_store_->RetrieveRequestedAttrs(
         arraysize(buffer), buffer, &num_copied));
   }
 }
 
 }  // namespace
 }  // namespace ui