Move Range code to gfx.

ui/base/ime/win/tsf_event_router.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_event_router.h"
 
 #include <msctf.h>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/metro.h"
-#include "ui/base/range/range.h"
 #include "ui/base/win/atl_module.h"
+#include "ui/gfx/range/range.h"
 
 namespace ui {
 
 
 // TSFEventRouter::Delegate  ------------------------------------
 
 // The implementation class of ITfUIElementSink, whose member functions will be
 // called back by TSF when the UI element status is changed, for example when
 // the candidate window is opened or closed. This class also implements
 // ITfTextEditSink, whose member function is called back by TSF when the text
@@ skipping 23 matching lines @@
   // Sets |thread_manager| to be monitored. |thread_manager| can be NULL.
   void SetManager(ITfThreadMgr* thread_manager);
 
   // Returns true if the IME is composing text.
   bool IsImeComposing();
 
   // Sets |router| to be forwarded TSF-related events.
   void SetRouter(TSFEventRouter* router);
 
  private:
-  // Returns current composition range. Returns ui::Range::InvalidRange if there
-  // is no composition.
-  static ui::Range GetCompositionRange(ITfContext* context);
+  // Returns current composition range. Returns gfx::Range::InvalidRange if
+  // there is no composition.
+  static gfx::Range GetCompositionRange(ITfContext* context);
 
   // Returns true if the given |element_id| represents the candidate window.
   bool IsCandidateWindowInternal(DWORD element_id);
 
   // A context associated with this class.
   base::win::ScopedComPtr<ITfContext> context_;
 
   // The ITfSource associated with |context_|.
   base::win::ScopedComPtr<ITfSource> context_source_;
 
   // The cookie for |context_source_|.
   DWORD context_source_cookie_;
 
   // A UIElementMgr associated with this class.
   base::win::ScopedComPtr<ITfUIElementMgr> ui_element_manager_;
 
   // The ITfSouce associated with |ui_element_manager_|.
   base::win::ScopedComPtr<ITfSource> ui_source_;
 
   // The set of currently opened candidate window ids.
   std::set<DWORD> open_candidate_window_ids_;
 
   // The cookie for |ui_source_|.
   DWORD ui_source_cookie_;
 
   TSFEventRouter* router_;
-  ui::Range previous_composition_range_;
+  gfx::Range previous_composition_range_;
 
   DISALLOW_COPY_AND_ASSIGN(Delegate);
 };
 
 TSFEventRouter::Delegate::Delegate()
     : context_source_cookie_(TF_INVALID_COOKIE),
       ui_source_cookie_(TF_INVALID_COOKIE),
       router_(NULL),
-      previous_composition_range_(ui::Range::InvalidRange()) {
+      previous_composition_range_(gfx::Range::InvalidRange()) {
 }
 
 TSFEventRouter::Delegate::~Delegate() {}
 
 void TSFEventRouter::Delegate::SetRouter(TSFEventRouter* router) {
   router_ = router;
 }
 
 STDMETHODIMP TSFEventRouter::Delegate::OnEndEdit(ITfContext* context,
                                                  TfEditCookie read_only_cookie,
@@ skipping 10 matching lines @@
   base::win::ScopedComPtr<IEnumTfRanges> ranges;
   if (FAILED(edit_record->GetTextAndPropertyUpdates(TF_GTP_INCL_TEXT, NULL, 0,
                                                     ranges.Receive())))
      return S_OK;  // Don't care about failures.
 
   ULONG fetched_count = 0;
   base::win::ScopedComPtr<ITfRange> range;
   if (FAILED(ranges->Next(1, range.Receive(), &fetched_count)))
     return S_OK;  // Don't care about failures.
 
-  const ui::Range composition_range = GetCompositionRange(context);
+  const gfx::Range composition_range = GetCompositionRange(context);
 
   if (!previous_composition_range_.IsValid() && composition_range.IsValid())
     router_->OnTSFStartComposition();
 
   // |fetched_count| != 0 means there is at least one range that contains
   // updated text.
   if (fetched_count != 0)
     router_->OnTextUpdated(composition_range);
 
   if (previous_composition_range_.IsValid() && !composition_range.IsValid())
@@ skipping 68 matching lines @@
   ui_source_->AdviseSink(IID_ITfUIElementSink,
                          static_cast<ITfUIElementSink*>(this),
                          &ui_source_cookie_);
 }
 
 bool TSFEventRouter::Delegate::IsImeComposing() {
   return context_ && GetCompositionRange(context_).IsValid();
 }
 
 // static
-ui::Range TSFEventRouter::Delegate::GetCompositionRange(
+gfx::Range TSFEventRouter::Delegate::GetCompositionRange(
     ITfContext* context) {
   DCHECK(context);
   base::win::ScopedComPtr<ITfContextComposition> context_composition;
   if (FAILED(context_composition.QueryFrom(context)))
-    return ui::Range::InvalidRange();
+    return gfx::Range::InvalidRange();
   base::win::ScopedComPtr<IEnumITfCompositionView> enum_composition_view;
   if (FAILED(context_composition->EnumCompositions(
       enum_composition_view.Receive())))
-    return ui::Range::InvalidRange();
+    return gfx::Range::InvalidRange();
   base::win::ScopedComPtr<ITfCompositionView> composition_view;
   if (enum_composition_view->Next(1, composition_view.Receive(),
                                   NULL) != S_OK)
-    return ui::Range::InvalidRange();
+    return gfx::Range::InvalidRange();
 
   base::win::ScopedComPtr<ITfRange> range;
   if (FAILED(composition_view->GetRange(range.Receive())))
-    return ui::Range::InvalidRange();
+    return gfx::Range::InvalidRange();
 
   base::win::ScopedComPtr<ITfRangeACP> range_acp;
   if (FAILED(range_acp.QueryFrom(range)))
-    return ui::Range::InvalidRange();
+    return gfx::Range::InvalidRange();
 
   LONG start = 0;
   LONG length = 0;
   if (FAILED(range_acp->GetExtent(&start, &length)))
-    return ui::Range::InvalidRange();
+    return gfx::Range::InvalidRange();
 
-  return ui::Range(start, start + length);
+  return gfx::Range(start, start + length);
 }
 
 bool TSFEventRouter::Delegate::IsCandidateWindowInternal(DWORD element_id) {
   DCHECK(ui_element_manager_.get());
   base::win::ScopedComPtr<ITfUIElement> ui_element;
   if (FAILED(ui_element_manager_->GetUIElement(element_id,
                                                ui_element.Receive())))
     return false;
   base::win::ScopedComPtr<ITfCandidateListUIElement> candidate_list_ui_element;
   return SUCCEEDED(candidate_list_ui_element.QueryFrom(ui_element));
@@ skipping 29 matching lines @@
 }
 
 void TSFEventRouter::OnCandidateWindowCountChanged(size_t window_count) {
   observer_->OnCandidateWindowCountChanged(window_count);
 }
 
 void TSFEventRouter::OnTSFStartComposition() {
   observer_->OnTSFStartComposition();
 }
 
-void TSFEventRouter::OnTextUpdated(const ui::Range& composition_range) {
+void TSFEventRouter::OnTextUpdated(const gfx::Range& composition_range) {
   observer_->OnTextUpdated(composition_range);
 }
 
 void TSFEventRouter::OnTSFEndComposition() {
   observer_->OnTSFEndComposition();
 }
 
 void TSFEventRouter::SetManager(ITfThreadMgr* thread_manager) {
   delegate_->SetManager(thread_manager);
 }
 
 }  // namespace ui