Rename TSFTextStore to TextStore

win8/metro_driver/ime/text_store.cc

 // Copyright 2013 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 "win8/metro_driver/ime/text_store.h"
 
 #include <algorithm>
 
 #include "base/win/scoped_variant.h"
 #include "ui/base/win/atl_module.h"
 #include "win8/metro_driver/ime/input_scope.h"
 #include "win8/metro_driver/ime/text_store_delegate.h"
 
 namespace metro_driver {
 namespace {
 
 // We support only one view.
 const TsViewCookie kViewCookie = 1;
 
 }  // namespace
 
-TSFTextStore::TSFTextStore()
+TextStore::TextStore()
     : text_store_acp_sink_mask_(0),
       window_handle_(NULL),
       delegate_(NULL),
       committed_size_(0),
       selection_start_(0),
       selection_end_(0),
       edit_flag_(false),
       current_lock_type_(0),
       category_manager_(NULL),
       display_attribute_manager_(NULL),
       input_scope_(NULL) {
 }
 
-TSFTextStore::~TSFTextStore() {
+TextStore::~TextStore() {
 }
 
 // static
-scoped_refptr<TSFTextStore> TSFTextStore::Create(
+scoped_refptr<TextStore> TextStore::Create(
     HWND window_handle,
     const std::vector<InputScope>& input_scopes,
     TextStoreDelegate* delegate) {
   if (!delegate) {
     LOG(ERROR) << "|delegate| must be non-NULL.";
-    return scoped_refptr<TSFTextStore>();
+    return scoped_refptr<TextStore>();
   }
   base::win::ScopedComPtr<ITfCategoryMgr> category_manager;
   HRESULT hr = category_manager.CreateInstance(CLSID_TF_CategoryMgr);
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to initialize CategoryMgr. hr = " << hr;
-    return scoped_refptr<TSFTextStore>();
+    return scoped_refptr<TextStore>();
   }
   base::win::ScopedComPtr<ITfDisplayAttributeMgr> display_attribute_manager;
   hr = display_attribute_manager.CreateInstance(CLSID_TF_DisplayAttributeMgr);
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to initialize DisplayAttributeMgr. hr = " << hr;
-    return scoped_refptr<TSFTextStore>();
+    return scoped_refptr<TextStore>();
   }
   base::win::ScopedComPtr<ITfInputScope> input_scope =
       CreteInputScope(input_scopes);
   if (!input_scope) {
     LOG(ERROR) << "Failed to initialize InputScope.";
-    return scoped_refptr<TSFTextStore>();
+    return scoped_refptr<TextStore>();
   }
 
   ui::win::CreateATLModuleIfNeeded();
-  CComObject<TSFTextStore>* object = NULL;
-  hr = CComObject<TSFTextStore>::CreateInstance(&object);
+  CComObject<TextStore>* object = NULL;
+  hr = CComObject<TextStore>::CreateInstance(&object);
   if (FAILED(hr)) {
-    LOG(ERROR) << "CComObject<TSFTextStore>::CreateInstance failed. hr = "
+    LOG(ERROR) << "CComObject<TextStore>::CreateInstance failed. hr = "
                << hr;
-    return scoped_refptr<TSFTextStore>();
+    return scoped_refptr<TextStore>();
   }
   object->Initialize(window_handle,
                      category_manager,
                      display_attribute_manager,
                      input_scope,
                      delegate);
-  return scoped_refptr<TSFTextStore>(object);
+  return scoped_refptr<TextStore>(object);
 }
 
-void TSFTextStore::Initialize(HWND window_handle,
-                              ITfCategoryMgr* category_manager,
-                              ITfDisplayAttributeMgr* display_attribute_manager,
-                              ITfInputScope* input_scope,
-                              TextStoreDelegate* delegate) {
+void TextStore::Initialize(HWND window_handle,
+                           ITfCategoryMgr* category_manager,
+                           ITfDisplayAttributeMgr* display_attribute_manager,
+                           ITfInputScope* input_scope,
+                           TextStoreDelegate* delegate) {
   window_handle_ = window_handle;
   category_manager_ = category_manager;
   display_attribute_manager_ = display_attribute_manager;
   input_scope_ = input_scope;
   delegate_ = delegate;
 }
 
 
-STDMETHODIMP TSFTextStore::AdviseSink(REFIID iid,
-                                      IUnknown* unknown,
-                                      DWORD mask) {
+STDMETHODIMP TextStore::AdviseSink(REFIID iid,
+                                   IUnknown* unknown,
+                                   DWORD mask) {
   if (!IsEqualGUID(iid, IID_ITextStoreACPSink))
     return E_INVALIDARG;
   if (text_store_acp_sink_) {
     if (text_store_acp_sink_.IsSameObject(unknown)) {
       text_store_acp_sink_mask_ = mask;
       return S_OK;
     } else {
       return CONNECT_E_ADVISELIMIT;
     }
   }
   if (FAILED(text_store_acp_sink_.QueryFrom(unknown)))
     return E_UNEXPECTED;
   text_store_acp_sink_mask_ = mask;
 
   return S_OK;
 }
 
-STDMETHODIMP TSFTextStore::FindNextAttrTransition(
+STDMETHODIMP TextStore::FindNextAttrTransition(
     LONG acp_start,
     LONG acp_halt,
     ULONG num_filter_attributes,
     const TS_ATTRID* filter_attributes,
     DWORD flags,
     LONG* acp_next,
     BOOL* found,
     LONG* found_offset) {
   if (!acp_next || !found || !found_offset)
     return E_INVALIDARG;
   // We don't support any attributes.
   // So we always return "not found".
   *acp_next = 0;
   *found = FALSE;
   *found_offset = 0;
   return S_OK;
 }
 
-STDMETHODIMP TSFTextStore::GetACPFromPoint(TsViewCookie view_cookie,
-                                           const POINT* point,
-                                           DWORD flags,
-                                           LONG* acp) {
+STDMETHODIMP TextStore::GetACPFromPoint(TsViewCookie view_cookie,
+                                        const POINT* point,
+                                        DWORD flags,
+                                        LONG* acp) {
   NOTIMPLEMENTED();
   if (view_cookie != kViewCookie)
     return E_INVALIDARG;
   return E_NOTIMPL;
 }
 
-STDMETHODIMP TSFTextStore::GetActiveView(TsViewCookie* view_cookie) {
+STDMETHODIMP TextStore::GetActiveView(TsViewCookie* view_cookie) {
   if (!view_cookie)
     return E_INVALIDARG;
   // We support only one view.
   *view_cookie = kViewCookie;
   return S_OK;
 }
 
-STDMETHODIMP TSFTextStore::GetEmbedded(LONG acp_pos,
-                                       REFGUID service,
-                                       REFIID iid,
-                                       IUnknown** unknown) {
+STDMETHODIMP TextStore::GetEmbedded(LONG acp_pos,
+                                    REFGUID service,
+                                    REFIID iid,
+                                    IUnknown** unknown) {
   // We don't support any embedded objects.
   NOTIMPLEMENTED();
   if (!unknown)
     return E_INVALIDARG;
   *unknown = NULL;
   return E_NOTIMPL;
 }
 
-STDMETHODIMP TSFTextStore::GetEndACP(LONG* acp) {
+STDMETHODIMP TextStore::GetEndACP(LONG* acp) {
   if (!acp)
     return E_INVALIDARG;
   if (!HasReadLock())
     return TS_E_NOLOCK;
   *acp = static_cast<LONG>(string_buffer_.size());
   return S_OK;
 }
 
-STDMETHODIMP TSFTextStore::GetFormattedText(LONG acp_start, LONG acp_end,
-                                            IDataObject** data_object) {
+STDMETHODIMP TextStore::GetFormattedText(LONG acp_start,
+                                         LONG acp_end,
+                                         IDataObject** data_object) {
   NOTIMPLEMENTED();
   return E_NOTIMPL;
 }
 
-STDMETHODIMP TSFTextStore::GetScreenExt(TsViewCookie view_cookie, RECT* rect) {
+STDMETHODIMP TextStore::GetScreenExt(TsViewCookie view_cookie, RECT* rect) {
   if (view_cookie != kViewCookie)
     return E_INVALIDARG;
   if (!rect)
     return E_INVALIDARG;
 
   // {0, 0, 0, 0} means that the document rect is not currently displayed.
   SetRect(rect, 0, 0, 0, 0);
 
   RECT client_rect = {};
   if (!GetClientRect(window_handle_, &client_rect))
     return E_FAIL;
   POINT left_top = {client_rect.left, client_rect.top};
   POINT right_bottom = {client_rect.right, client_rect.bottom};
   if (!ClientToScreen(window_handle_, &left_top))
     return E_FAIL;
   if (!ClientToScreen(window_handle_, &right_bottom))
     return E_FAIL;
 
   rect->left = left_top.x;
   rect->top = left_top.y;
   rect->right = right_bottom.x;
   rect->bottom = right_bottom.y;
   return S_OK;
 }
 
-STDMETHODIMP TSFTextStore::GetSelection(ULONG selection_index,
-                                        ULONG selection_buffer_size,
-                                        TS_SELECTION_ACP* selection_buffer,
-                                        ULONG* fetched_count) {
+STDMETHODIMP TextStore::GetSelection(ULONG selection_index,
+                                     ULONG selection_buffer_size,
+                                     TS_SELECTION_ACP* selection_buffer,
+                                     ULONG* fetched_count) {
   if (!selection_buffer)
     return E_INVALIDARG;
   if (!fetched_count)
     return E_INVALIDARG;
   if (!HasReadLock())
     return TS_E_NOLOCK;
   *fetched_count = 0;
   if ((selection_buffer_size > 0) &&
       ((selection_index == 0) || (selection_index == TS_DEFAULT_SELECTION))) {
     selection_buffer[0].acpStart = selection_start_;
     selection_buffer[0].acpEnd = selection_end_;
     selection_buffer[0].style.ase = TS_AE_END;
     selection_buffer[0].style.fInterimChar = FALSE;
     *fetched_count = 1;
   }
   return S_OK;
 }
 
-STDMETHODIMP TSFTextStore::GetStatus(TS_STATUS* status) {
+STDMETHODIMP TextStore::GetStatus(TS_STATUS* status) {
   if (!status)
     return E_INVALIDARG;
 
   status->dwDynamicFlags = 0;
   // We use transitory contexts and we don't support hidden text.
   status->dwStaticFlags = TS_SS_TRANSITORY | TS_SS_NOHIDDENTEXT;
 
   return S_OK;
 }
 
-STDMETHODIMP TSFTextStore::GetText(LONG acp_start,
-                                   LONG acp_end,
-                                   wchar_t* text_buffer,
-                                   ULONG text_buffer_size,
-                                   ULONG* text_buffer_copied,
-                                   TS_RUNINFO* run_info_buffer,
-                                   ULONG run_info_buffer_size,
-                                   ULONG* run_info_buffer_copied,
-                                   LONG* next_acp) {
+STDMETHODIMP TextStore::GetText(LONG acp_start,
+                                LONG acp_end,
+                                wchar_t* text_buffer,
+                                ULONG text_buffer_size,
+                                ULONG* text_buffer_copied,
+                                TS_RUNINFO* run_info_buffer,
+                                ULONG run_info_buffer_size,
+                                ULONG* run_info_buffer_copied,
+                                LONG* next_acp) {
   if (!text_buffer_copied || !run_info_buffer_copied)
     return E_INVALIDARG;
   if (!text_buffer && text_buffer_size != 0)
     return E_INVALIDARG;
   if (!run_info_buffer && run_info_buffer_size != 0)
     return E_INVALIDARG;
   if (!next_acp)
     return E_INVALIDARG;
   if (!HasReadLock())
     return TF_E_NOLOCK;
@@ skipping 16 matching lines @@
   if (run_info_buffer_size) {
     run_info_buffer[0].uCount = *text_buffer_copied;
     run_info_buffer[0].type = TS_RT_PLAIN;
     *run_info_buffer_copied = 1;
   }
 
   *next_acp = acp_end;
   return S_OK;
 }
 
-STDMETHODIMP TSFTextStore::GetTextExt(TsViewCookie view_cookie,
-                                      LONG acp_start,
-                                      LONG acp_end,
-                                      RECT* rect,
-                                      BOOL* clipped) {
+STDMETHODIMP TextStore::GetTextExt(TsViewCookie view_cookie,
+                                   LONG acp_start,
+                                   LONG acp_end,
+                                   RECT* rect,
+                                   BOOL* clipped) {
   if (!rect || !clipped)
     return E_INVALIDARG;
   if (view_cookie != kViewCookie)
     return E_INVALIDARG;
   if (!HasReadLock())
     return TS_E_NOLOCK;
   if (!((static_cast<LONG>(committed_size_) <= acp_start) &&
        (acp_start <= acp_end) &&
        (acp_end <= static_cast<LONG>(string_buffer_.size())))) {
     return TS_E_INVALIDPOS;
@@ skipping 50 matching lines @@
       else
         return TS_E_NOLAYOUT;
     }
   }
 
   *rect =  result;
   *clipped = FALSE;
   return S_OK;
 }
 
-STDMETHODIMP TSFTextStore::GetWnd(TsViewCookie view_cookie,
-                                  HWND* window_handle) {
+STDMETHODIMP TextStore::GetWnd(TsViewCookie view_cookie,
+                               HWND* window_handle) {
   if (!window_handle)
     return E_INVALIDARG;
   if (view_cookie != kViewCookie)
     return E_INVALIDARG;
   *window_handle = window_handle_;
   return S_OK;
 }
 
-STDMETHODIMP TSFTextStore::InsertEmbedded(DWORD flags,
-                                          LONG acp_start,
-                                          LONG acp_end,
-                                          IDataObject* data_object,
-                                          TS_TEXTCHANGE* change) {
+STDMETHODIMP TextStore::InsertEmbedded(DWORD flags,
+                                       LONG acp_start,
+                                       LONG acp_end,
+                                       IDataObject* data_object,
+                                       TS_TEXTCHANGE* change) {
   // We don't support any embedded objects.
   NOTIMPLEMENTED();
   return E_NOTIMPL;
 }
 
-STDMETHODIMP TSFTextStore::InsertEmbeddedAtSelection(DWORD flags,
-                                                     IDataObject* data_object,
-                                                     LONG* acp_start,
-                                                     LONG* acp_end,
-                                                     TS_TEXTCHANGE* change) {
+STDMETHODIMP TextStore::InsertEmbeddedAtSelection(DWORD flags,
+                                                  IDataObject* data_object,
+                                                  LONG* acp_start,
+                                                  LONG* acp_end,
+                                                  TS_TEXTCHANGE* change) {
   // We don't support any embedded objects.
   NOTIMPLEMENTED();
   return E_NOTIMPL;
 }
 
-STDMETHODIMP TSFTextStore::InsertTextAtSelection(DWORD flags,
-                                                 const wchar_t* text_buffer,
-                                                 ULONG text_buffer_size,
-                                                 LONG* acp_start,
-                                                 LONG* acp_end,
-                                                 TS_TEXTCHANGE* text_change) {
+STDMETHODIMP TextStore::InsertTextAtSelection(DWORD flags,
+                                              const wchar_t* text_buffer,
+                                              ULONG text_buffer_size,
+                                              LONG* acp_start,
+                                              LONG* acp_end,
+                                              TS_TEXTCHANGE* text_change) {
   const LONG start_pos = selection_start_;
   const LONG end_pos = selection_end_;
   const LONG new_end_pos = start_pos + text_buffer_size;
 
   if (flags & TS_IAS_QUERYONLY) {
     if (!HasReadLock())
       return TS_E_NOLOCK;
     if (acp_start)
       *acp_start = start_pos;
     if (acp_end)
@@ skipping 17 matching lines @@
   if (text_change) {
     text_change->acpStart = start_pos;
     text_change->acpOldEnd = end_pos;
     text_change->acpNewEnd = new_end_pos;
   }
   selection_start_ = start_pos;
   selection_end_ = new_end_pos;
   return S_OK;
 }
 
-STDMETHODIMP TSFTextStore::QueryInsert(
+STDMETHODIMP TextStore::QueryInsert(
     LONG acp_test_start,
     LONG acp_test_end,
     ULONG text_size,
     LONG* acp_result_start,
     LONG* acp_result_end) {
   if (!acp_result_start || !acp_result_end || acp_test_start > acp_test_end)
     return E_INVALIDARG;
   const LONG committed_size = static_cast<LONG>(committed_size_);
   const LONG buffer_size = static_cast<LONG>(string_buffer_.size());
   *acp_result_start = std::min(std::max(committed_size, acp_test_start),
                                buffer_size);
   *acp_result_end = std::min(std::max(committed_size, acp_test_end),
                              buffer_size);
   return S_OK;
 }
 
-STDMETHODIMP TSFTextStore::QueryInsertEmbedded(const GUID* service,
+STDMETHODIMP TextStore::QueryInsertEmbedded(const GUID* service,
                                                const FORMATETC* format,
                                                BOOL* insertable) {
   if (!format)
     return E_INVALIDARG;
   // We don't support any embedded objects.
   if (insertable)
     *insertable = FALSE;
   return S_OK;
 }
 
-STDMETHODIMP TSFTextStore::RequestAttrsAtPosition(
+STDMETHODIMP TextStore::RequestAttrsAtPosition(
     LONG acp_pos,
     ULONG attribute_buffer_size,
     const TS_ATTRID* attribute_buffer,
     DWORD flags) {
   // We don't support any document attributes.
   // This method just returns S_OK, and the subsequently called
   // RetrieveRequestedAttrs() returns 0 as the number of supported attributes.
   return S_OK;
 }
 
-STDMETHODIMP TSFTextStore::RequestAttrsTransitioningAtPosition(
+STDMETHODIMP TextStore::RequestAttrsTransitioningAtPosition(
     LONG acp_pos,
     ULONG attribute_buffer_size,
     const TS_ATTRID* attribute_buffer,
     DWORD flags) {
   // We don't support any document attributes.
   // This method just returns S_OK, and the subsequently called
   // RetrieveRequestedAttrs() returns 0 as the number of supported attributes.
   return S_OK;
 }
 
-STDMETHODIMP TSFTextStore::RequestLock(DWORD lock_flags, HRESULT* result) {
+STDMETHODIMP TextStore::RequestLock(DWORD lock_flags, HRESULT* result) {
   if (!text_store_acp_sink_.get())
     return E_FAIL;
   if (!result)
     return E_INVALIDARG;
 
   if (current_lock_type_ != 0) {
     if (lock_flags & TS_LF_SYNC) {
       // Can't lock synchronously.
       *result = TS_E_SYNCHRONOUS;
       return S_OK;
@@ skipping 74 matching lines @@
       textChange.acpStart = 0;
       textChange.acpOldEnd = new_committed_size;
       textChange.acpNewEnd = 0;
       text_store_acp_sink_->OnTextChange(0, &textChange);
     }
   }
 
   return S_OK;
 }
 
-STDMETHODIMP TSFTextStore::RequestSupportedAttrs(
+STDMETHODIMP TextStore::RequestSupportedAttrs(
     DWORD /* flags */,  // Seems that we should ignore this.
     ULONG attribute_buffer_size,
     const TS_ATTRID* attribute_buffer) {
   if (!attribute_buffer)
     return E_INVALIDARG;
   if (!input_scope_)
     return E_FAIL;
   // We support only input scope attribute.
   for (size_t i = 0; i < attribute_buffer_size; ++i) {
     if (IsEqualGUID(GUID_PROP_INPUTSCOPE, attribute_buffer[i]))
       return S_OK;
   }
   return E_FAIL;
 }
 
-STDMETHODIMP TSFTextStore::RetrieveRequestedAttrs(
+STDMETHODIMP TextStore::RetrieveRequestedAttrs(
     ULONG attribute_buffer_size,
     TS_ATTRVAL* attribute_buffer,
     ULONG* attribute_buffer_copied) {
   if (!attribute_buffer_copied)
     return E_INVALIDARG;
   *attribute_buffer_copied = 0;
   if (!attribute_buffer)
     return E_INVALIDARG;
   if (!input_scope_)
     return E_UNEXPECTED;
   // We support only input scope attribute.
   *attribute_buffer_copied = 0;
   if (attribute_buffer_size == 0)
     return S_OK;
 
   attribute_buffer[0].dwOverlapId = 0;
   attribute_buffer[0].idAttr = GUID_PROP_INPUTSCOPE;
   attribute_buffer[0].varValue.vt = VT_UNKNOWN;
   attribute_buffer[0].varValue.punkVal = input_scope_.get();
   attribute_buffer[0].varValue.punkVal->AddRef();
   *attribute_buffer_copied = 1;
   return S_OK;
 }
 
-STDMETHODIMP TSFTextStore::SetSelection(
+STDMETHODIMP TextStore::SetSelection(
     ULONG selection_buffer_size,
     const TS_SELECTION_ACP* selection_buffer) {
   if (!HasReadWriteLock())
     return TF_E_NOLOCK;
   if (selection_buffer_size > 0) {
     const LONG start_pos = selection_buffer[0].acpStart;
     const LONG end_pos = selection_buffer[0].acpEnd;
     if (!((static_cast<LONG>(committed_size_) <= start_pos) &&
           (start_pos <= end_pos) &&
           (end_pos <= static_cast<LONG>(string_buffer_.size())))) {
       return TF_E_INVALIDPOS;
     }
     selection_start_ = start_pos;
     selection_end_ = end_pos;
   }
   return S_OK;
 }
 
-STDMETHODIMP TSFTextStore::SetText(DWORD flags,
-                                   LONG acp_start,
-                                   LONG acp_end,
-                                   const wchar_t* text_buffer,
-                                   ULONG text_buffer_size,
-                                   TS_TEXTCHANGE* text_change) {
+STDMETHODIMP TextStore::SetText(DWORD flags,
+                                LONG acp_start,
+                                LONG acp_end,
+                                const wchar_t* text_buffer,
+                                ULONG text_buffer_size,
+                                TS_TEXTCHANGE* text_change) {
   if (!HasReadWriteLock())
     return TS_E_NOLOCK;
   if (!((static_cast<LONG>(committed_size_) <= acp_start) &&
         (acp_start <= acp_end) &&
         (acp_end <= static_cast<LONG>(string_buffer_.size())))) {
     return TS_E_INVALIDPOS;
   }
 
   TS_SELECTION_ACP selection;
   selection.acpStart = acp_start;
@@ skipping 11 matching lines @@
                               &acp_start, &acp_end, &change);
   if (ret != S_OK)
     return ret;
 
   if (text_change)
     *text_change = change;
 
   return S_OK;
 }
 
-STDMETHODIMP TSFTextStore::UnadviseSink(IUnknown* unknown) {
+STDMETHODIMP TextStore::UnadviseSink(IUnknown* unknown) {
   if (!text_store_acp_sink_.IsSameObject(unknown))
     return CONNECT_E_NOCONNECTION;
   text_store_acp_sink_.Release();
   text_store_acp_sink_mask_ = 0;
   return S_OK;
 }
 
-STDMETHODIMP TSFTextStore::OnStartComposition(
+STDMETHODIMP TextStore::OnStartComposition(
     ITfCompositionView* composition_view,
     BOOL* ok) {
   if (ok)
     *ok = TRUE;
   return S_OK;
 }
 
-STDMETHODIMP TSFTextStore::OnUpdateComposition(
+STDMETHODIMP TextStore::OnUpdateComposition(
     ITfCompositionView* composition_view,
     ITfRange* range) {
   return S_OK;
 }
 
-STDMETHODIMP TSFTextStore::OnEndComposition(
+STDMETHODIMP TextStore::OnEndComposition(
     ITfCompositionView* composition_view) {
   return S_OK;
 }
 
-STDMETHODIMP TSFTextStore::OnEndEdit(ITfContext* context,
+STDMETHODIMP TextStore::OnEndEdit(ITfContext* context,
                                   TfEditCookie read_only_edit_cookie,
                                   ITfEditRecord* edit_record) {
   if (!context || !edit_record)
     return E_INVALIDARG;
   if (!GetCompositionStatus(context, read_only_edit_cookie, &committed_size_,
                             &underlines_)) {
     return S_OK;
   }
   edit_flag_ = true;
   return S_OK;
 }
 
-bool TSFTextStore::GetDisplayAttribute(TfGuidAtom guid_atom,
-                                       TF_DISPLAYATTRIBUTE* attribute) {
+bool TextStore::GetDisplayAttribute(TfGuidAtom guid_atom,
+                                    TF_DISPLAYATTRIBUTE* attribute) {
   GUID guid;
   if (FAILED(category_manager_->GetGUID(guid_atom, &guid)))
     return false;
 
   base::win::ScopedComPtr<ITfDisplayAttributeInfo> display_attribute_info;
   if (FAILED(display_attribute_manager_->GetDisplayAttributeInfo(
           guid, display_attribute_info.Receive(), NULL))) {
     return false;
   }
   return SUCCEEDED(display_attribute_info->GetAttributeInfo(attribute));
 }
 
-bool TSFTextStore::GetCompositionStatus(
+bool TextStore::GetCompositionStatus(
     ITfContext* context,
     const TfEditCookie read_only_edit_cookie,
     uint32* committed_size,
     std::vector<metro_viewer::UnderlineInfo>* undelines) {
   DCHECK(context);
   DCHECK(committed_size);
   DCHECK(undelines);
   const GUID* rgGuids[2] = {&GUID_PROP_COMPOSING, &GUID_PROP_ATTRIBUTE};
   base::win::ScopedComPtr<ITfReadOnlyProperty> track_property;
   if (FAILED(context->TrackProperties(rgGuids, 2, NULL, 0,
@@ skipping 62 matching lines @@
       metro_viewer::UnderlineInfo underline;
       underline.start_offset = start_pos;
       underline.end_offset = start_pos + length;
       underline.thick = !!display_attribute.fBoldLine;
       undelines->push_back(underline);
     }
   }
   return true;
 }
 
-bool TSFTextStore::CancelComposition() {
+bool TextStore::CancelComposition() {
   // If there is an on-going document lock, we must not edit the text.
   if (edit_flag_)
     return false;
 
   if (string_buffer_.empty())
     return true;
 
   // Unlike ImmNotifyIME(NI_COMPOSITIONSTR, CPS_CANCEL, 0) in IMM32, TSF does
   // not have a dedicated method to cancel composition. However, CUAS actually
   // has a protocol conversion from CPS_CANCEL into TSF operations. According
@@ skipping 15 matching lines @@
   if (text_store_acp_sink_mask_ & TS_AS_TEXT_CHANGE) {
     TS_TEXTCHANGE textChange = {};
     textChange.acpStart = 0;
     textChange.acpOldEnd = previous_buffer_size;
     textChange.acpNewEnd = 0;
     text_store_acp_sink_->OnTextChange(0, &textChange);
   }
   return true;
 }
 
-bool TSFTextStore::ConfirmComposition() {
+bool TextStore::ConfirmComposition() {
   // If there is an on-going document lock, we must not edit the text.
   if (edit_flag_)
     return false;
 
   if (string_buffer_.empty())
     return true;
 
-  // See the comment in TSFTextStore::CancelComposition.
+  // See the comment in TextStore::CancelComposition.
   // This logic is based on the observation about how to emulate
   // ImmNotifyIME(NI_COMPOSITIONSTR, CPS_COMPLETE, 0) by CUAS.
 
   const string16& composition_text = string_buffer_.substr(committed_size_);
   if (!composition_text.empty())
     delegate_->OnTextCommitted(composition_text);
 
   const uint32 previous_buffer_size =
       static_cast<uint32>(string_buffer_.size());
   string_buffer_.clear();
   committed_size_ = 0;
   selection_start_ = 0;
   selection_end_ = 0;
   if (text_store_acp_sink_mask_ & TS_AS_SEL_CHANGE)
     text_store_acp_sink_->OnSelectionChange();
   if (text_store_acp_sink_mask_ & TS_AS_LAYOUT_CHANGE)
     text_store_acp_sink_->OnLayoutChange(TS_LC_CHANGE, 0);
   if (text_store_acp_sink_mask_ & TS_AS_TEXT_CHANGE) {
     TS_TEXTCHANGE textChange = {};
     textChange.acpStart = 0;
     textChange.acpOldEnd = previous_buffer_size;
     textChange.acpNewEnd = 0;
     text_store_acp_sink_->OnTextChange(0, &textChange);
   }
   return true;
 }
 
-void TSFTextStore::SendOnLayoutChange() {
+void TextStore::SendOnLayoutChange() {
   if (text_store_acp_sink_ && (text_store_acp_sink_mask_ & TS_AS_LAYOUT_CHANGE))
     text_store_acp_sink_->OnLayoutChange(TS_LC_CHANGE, 0);
 }
 
-bool TSFTextStore::HasReadLock() const {
+bool TextStore::HasReadLock() const {
   return (current_lock_type_ & TS_LF_READ) == TS_LF_READ;
 }
 
-bool TSFTextStore::HasReadWriteLock() const {
+bool TextStore::HasReadWriteLock() const {
   return (current_lock_type_ & TS_LF_READWRITE) == TS_LF_READWRITE;
 }
 
 }  // namespace metro_driver