Move text_field.cc and rename the class to Textfield in preparation for porti...

views/controls/textfield/textfield.cc

 // Copyright (c) 2009 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 "views/controls/text_field.h"
+#include "views/controls/textfield/textfield.h"
 
 #include <atlbase.h>
 #include <atlapp.h>
 #include <atlcrack.h>
 #include <atlctrls.h>
 #include <atlmisc.h>
 #include <tom.h>  // For ITextDocument, a COM interface to CRichEditCtrl
 #include <vsstyle.h>
 
 #include "app/gfx/insets.h"
@@ skipping 12 matching lines @@
 #include "views/focus/focus_util_win.h"
 #include "views/views_delegate.h"
 #include "views/widget/widget.h"
 
 using gfx::NativeTheme;
 
 namespace views {
 
 static const int kDefaultEditStyle = WS_CHILD | WS_VISIBLE;
 
-class TextField::Edit
-    : public CWindowImpl<TextField::Edit, CRichEditCtrl,
+class Textfield::Edit
+    : public CWindowImpl<Textfield::Edit, CRichEditCtrl,
                          CWinTraits<kDefaultEditStyle> >,
-      public CRichEditCommands<TextField::Edit>,
+      public CRichEditCommands<Textfield::Edit>,
       public Menu::Delegate {
  public:
-  DECLARE_WND_CLASS(L"ChromeViewsTextFieldEdit");
+  DECLARE_WND_CLASS(L"ChromeViewsTextfieldEdit");
 
-  Edit(TextField* parent, bool draw_border);
+  Edit(Textfield* parent, bool draw_border);
   ~Edit();
 
   std::wstring GetText() const;
   void SetText(const std::wstring& text);
   void AppendText(const std::wstring& text);
 
   std::wstring GetSelectedText() const;
 
   // Selects all the text in the edit.  Use this in place of SetSelAll() to
   // avoid selecting the "phantom newline" at the end of the edit.
@@ skipping 122 matching lines @@
   bool can_discard_mousemove_;
 
   // The text of this control before a possible change.
   std::wstring text_before_change_;
 
   // If true, the mouse is over the edit.
   bool contains_mouse_;
 
   static bool did_load_library_;
 
-  TextField* parent_;
+  Textfield* parent_;
 
   // The context menu for the edit.
   scoped_ptr<Menu> context_menu_;
 
   // Border insets.
   gfx::Insets content_insets_;
 
   // Whether the border is drawn.
   bool draw_border_;
 
   // This interface is useful for accessing the CRichEditCtrl at a low level.
   mutable CComQIPtr<ITextDocument> text_object_model_;
 
   // The position and the length of the ongoing composition string.
   // These values are used for removing a composition string from a search
   // text to emulate Firefox.
   bool ime_discard_composition_;
   int ime_composition_start_;
   int ime_composition_length_;
 
   COLORREF bg_color_;
 
   DISALLOW_COPY_AND_ASSIGN(Edit);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // Helper classes
 
-TextField::Edit::ScopedFreeze::ScopedFreeze(TextField::Edit* edit,
+Textfield::Edit::ScopedFreeze::ScopedFreeze(Textfield::Edit* edit,
                                             ITextDocument* text_object_model)
     : edit_(edit),
       text_object_model_(text_object_model) {
   // Freeze the screen.
   if (text_object_model_) {
     long count;
     text_object_model_->Freeze(&count);
   }
 }
 
-TextField::Edit::ScopedFreeze::~ScopedFreeze() {
+Textfield::Edit::ScopedFreeze::~ScopedFreeze() {
   // Unfreeze the screen.
   if (text_object_model_) {
     long count;
     text_object_model_->Unfreeze(&count);
     if (count == 0) {
       // We need to UpdateWindow() here instead of InvalidateRect() because, as
       // far as I can tell, the edit likes to synchronously erase its background
       // when unfreezing, thus requiring us to synchronously redraw if we don't
       // want flicker.
       edit_->UpdateWindow();
     }
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// TextField::Edit
+// Textfield::Edit
 
-bool TextField::Edit::did_load_library_ = false;
+bool Textfield::Edit::did_load_library_ = false;
 
-TextField::Edit::Edit(TextField* parent, bool draw_border)
+Textfield::Edit::Edit(Textfield* parent, bool draw_border)
     : parent_(parent),
       tracking_double_click_(false),
       double_click_time_(0),
       can_discard_mousemove_(false),
       contains_mouse_(false),
       draw_border_(draw_border),
       ime_discard_composition_(false),
       ime_composition_start_(0),
       ime_composition_length_(0),
       bg_color_(0) {
   if (!did_load_library_)
     did_load_library_ = !!LoadLibrary(L"riched20.dll");
 
   DWORD style = kDefaultEditStyle;
-  if (parent->GetStyle() & TextField::STYLE_PASSWORD)
+  if (parent->GetStyle() & Textfield::STYLE_PASSWORD)
     style |= ES_PASSWORD;
 
   if (parent->read_only_)
     style |= ES_READONLY;
 
-  if (parent->GetStyle() & TextField::STYLE_MULTILINE)
+  if (parent->GetStyle() & Textfield::STYLE_MULTILINE)
     style |= ES_MULTILINE | ES_WANTRETURN | ES_AUTOVSCROLL;
   else
     style |= ES_AUTOHSCROLL;
   // Make sure we apply RTL related extended window styles if necessary.
   DWORD ex_style = l10n_util::GetExtendedStyles();
 
   RECT r = {0, 0, parent_->width(), parent_->height()};
   Create(parent_->GetWidget()->GetNativeView(), r, NULL, style, ex_style);
 
-  if (parent->GetStyle() & TextField::STYLE_LOWERCASE) {
-    DCHECK((parent->GetStyle() & TextField::STYLE_PASSWORD) == 0);
+  if (parent->GetStyle() & Textfield::STYLE_LOWERCASE) {
+    DCHECK((parent->GetStyle() & Textfield::STYLE_PASSWORD) == 0);
     SetEditStyle(SES_LOWERCASE, SES_LOWERCASE);
   }
 
   // Set up the text_object_model_.
   CComPtr<IRichEditOle> ole_interface;
   ole_interface.Attach(GetOleInterface());
   text_object_model_ = ole_interface;
 
   context_menu_.reset(new MenuWin(this, Menu::TOPLEFT, m_hWnd));
   context_menu_->AppendMenuItemWithLabel(IDS_APP_UNDO,
                                          l10n_util::GetString(IDS_APP_UNDO));
   context_menu_->AppendSeparator();
   context_menu_->AppendMenuItemWithLabel(IDS_APP_CUT,
                                          l10n_util::GetString(IDS_APP_CUT));
   context_menu_->AppendMenuItemWithLabel(IDS_APP_COPY,
                                          l10n_util::GetString(IDS_APP_COPY));
   context_menu_->AppendMenuItemWithLabel(IDS_APP_PASTE,
                                          l10n_util::GetString(IDS_APP_PASTE));
   context_menu_->AppendSeparator();
   context_menu_->AppendMenuItemWithLabel(IDS_APP_SELECT_ALL,
                                          l10n_util::GetString(IDS_APP_SELECT_ALL));
 }
 
-TextField::Edit::~Edit() {
+Textfield::Edit::~Edit() {
 }
 
-std::wstring TextField::Edit::GetText() const {
+std::wstring Textfield::Edit::GetText() const {
   int len = GetTextLength() + 1;
   std::wstring str;
   GetWindowText(WriteInto(&str, len), len);
   return str;
 }
 
-void TextField::Edit::SetText(const std::wstring& text) {
+void Textfield::Edit::SetText(const std::wstring& text) {
   // Adjusting the string direction before setting the text in order to make
   // sure both RTL and LTR strings are displayed properly.
   std::wstring text_to_set;
   if (!l10n_util::AdjustStringForLocaleDirection(text, &text_to_set))
     text_to_set = text;
   if (parent_->GetStyle() & STYLE_LOWERCASE)
     text_to_set = l10n_util::ToLower(text_to_set);
   SetWindowText(text_to_set.c_str());
 }
 
-void TextField::Edit::AppendText(const std::wstring& text) {
+void Textfield::Edit::AppendText(const std::wstring& text) {
   int text_length = GetWindowTextLength();
   ::SendMessage(m_hWnd, TBM_SETSEL, true, MAKELPARAM(text_length, text_length));
   ::SendMessage(m_hWnd, EM_REPLACESEL, false,
                 reinterpret_cast<LPARAM>(text.c_str()));
 }
 
-std::wstring TextField::Edit::GetSelectedText() const {
+std::wstring Textfield::Edit::GetSelectedText() const {
   // Figure out the length of the selection.
   long start;
   long end;
   GetSel(start, end);
 
   // Grab the selected text.
   std::wstring str;
   GetSelText(WriteInto(&str, end - start + 1));
 
   return str;
 }
 
-void TextField::Edit::SelectAll() {
+void Textfield::Edit::SelectAll() {
   // Select from the end to the front so that the first part of the text is
   // always visible.
   SetSel(GetTextLength(), 0);
 }
 
-void TextField::Edit::ClearSelection() {
+void Textfield::Edit::ClearSelection() {
   SetSel(GetTextLength(), GetTextLength());
 }
 
-void TextField::Edit::RemoveBorder() {
+void Textfield::Edit::RemoveBorder() {
   if (!draw_border_)
     return;
 
   draw_border_ = false;
   SetWindowPos(NULL, 0, 0, 0, 0,
                SWP_NOMOVE | SWP_FRAMECHANGED | SWP_NOACTIVATE |
                SWP_NOOWNERZORDER | SWP_NOSIZE);
 }
 
-void TextField::Edit::SetEnabled(bool enabled) {
+void Textfield::Edit::SetEnabled(bool enabled) {
   SendMessage(parent_->GetNativeComponent(), WM_ENABLE,
               static_cast<WPARAM>(enabled), 0);
 }
 
 // static
-bool TextField::IsKeystrokeEnter(const Keystroke& key) {
+bool Textfield::IsKeystrokeEnter(const Keystroke& key) {
   return key.key == VK_RETURN;
 }
 
 // static
-bool TextField::IsKeystrokeEscape(const Keystroke& key) {
+bool Textfield::IsKeystrokeEscape(const Keystroke& key) {
   return key.key == VK_ESCAPE;
 }
 
-void TextField::Edit::SetBackgroundColor(COLORREF bg_color) {
+void Textfield::Edit::SetBackgroundColor(COLORREF bg_color) {
   CRichEditCtrl::SetBackgroundColor(bg_color);
   bg_color_ = bg_color;
 }
 
-bool TextField::Edit::IsCommandEnabled(int id) const {
+bool Textfield::Edit::IsCommandEnabled(int id) const {
   switch (id) {
     case IDS_APP_UNDO:       return !parent_->IsReadOnly() && !!CanUndo();
     case IDS_APP_CUT:        return !parent_->IsReadOnly() &&
                                  !parent_->IsPassword() && !!CanCut();
     case IDS_APP_COPY:       return !!CanCopy() && !parent_->IsPassword();
     case IDS_APP_PASTE:      return !parent_->IsReadOnly() && !!CanPaste();
     case IDS_APP_SELECT_ALL: return !!CanSelectAll();
     default:                 NOTREACHED();
                              return false;
   }
 }
 
-void TextField::Edit::ExecuteCommand(int id) {
+void Textfield::Edit::ExecuteCommand(int id) {
   ScopedFreeze freeze(this, GetTextObjectModel());
   OnBeforePossibleChange();
   switch (id) {
     case IDS_APP_UNDO:       Undo();       break;
     case IDS_APP_CUT:        Cut();        break;
     case IDS_APP_COPY:       Copy();       break;
     case IDS_APP_PASTE:      Paste();      break;
     case IDS_APP_SELECT_ALL: SelectAll();  break;
     default:                 NOTREACHED(); break;
   }
   OnAfterPossibleChange();
 }
 
-void TextField::Edit::OnChar(TCHAR ch, UINT repeat_count, UINT flags) {
+void Textfield::Edit::OnChar(TCHAR ch, UINT repeat_count, UINT flags) {
   HandleKeystroke(GetCurrentMessage()->message, ch, repeat_count, flags);
 }
 
-void TextField::Edit::OnContextMenu(HWND window, const CPoint& point) {
+void Textfield::Edit::OnContextMenu(HWND window, const CPoint& point) {
   CPoint p(point);
   if (point.x == -1 || point.y == -1) {
     GetCaretPos(&p);
     MapWindowPoints(HWND_DESKTOP, &p, 1);
   }
   context_menu_->RunMenuAt(p.x, p.y);
 }
 
-void TextField::Edit::OnCopy() {
+void Textfield::Edit::OnCopy() {
   if (parent_->IsPassword())
     return;
 
   const std::wstring text(GetSelectedText());
 
   if (!text.empty() && ViewsDelegate::views_delegate) {
     ScopedClipboardWriter scw(ViewsDelegate::views_delegate->GetClipboard());
     scw.WriteText(text);
   }
 }
 
-void TextField::Edit::OnCut() {
+void Textfield::Edit::OnCut() {
   if (parent_->IsReadOnly() || parent_->IsPassword())
     return;
 
   OnCopy();
 
   // This replace selection will have no effect (even on the undo stack) if the
   // current selection is empty.
   ReplaceSel(L"", true);
 }
 
-LRESULT TextField::Edit::OnImeChar(UINT message, WPARAM wparam, LPARAM lparam) {
+LRESULT Textfield::Edit::OnImeChar(UINT message, WPARAM wparam, LPARAM lparam) {
   // http://crbug.com/7707: a rich-edit control may crash when it receives a
   // WM_IME_CHAR message while it is processing a WM_IME_COMPOSITION message.
   // Since view controls don't need WM_IME_CHAR messages, we prevent WM_IME_CHAR
   // messages from being dispatched to view controls via the CallWindowProc()
   // call.
   return 0;
 }
 
-LRESULT TextField::Edit::OnImeStartComposition(UINT message,
+LRESULT Textfield::Edit::OnImeStartComposition(UINT message,
                                                WPARAM wparam,
                                                LPARAM lparam) {
   // Users may press alt+shift or control+shift keys to change their keyboard
   // layouts. So, we retrieve the input locale identifier everytime we start
   // an IME composition.
   int language_id = PRIMARYLANGID(GetKeyboardLayout(0));
   ime_discard_composition_ =
       language_id == LANG_JAPANESE || language_id == LANG_CHINESE;
   ime_composition_start_ = 0;
   ime_composition_length_ = 0;
 
   return DefWindowProc(message, wparam, lparam);
 }
 
-LRESULT TextField::Edit::OnImeComposition(UINT message,
+LRESULT Textfield::Edit::OnImeComposition(UINT message,
                                           WPARAM wparam,
                                           LPARAM lparam) {
   text_before_change_.clear();
   LRESULT result = DefWindowProc(message, wparam, lparam);
 
   ime_composition_start_ = 0;
   ime_composition_length_ = 0;
   if (ime_discard_composition_) {
     // Call IMM32 functions to retrieve the position and the length of the
     // ongoing composition string and notify the OnAfterPossibleChange()
@@ skipping 15 matching lines @@
         ime_composition_length_ = composition_size / sizeof(wchar_t);
 
       ImmReleaseContext(m_hWnd, imm_context);
     }
   }
 
   OnAfterPossibleChange();
   return result;
 }
 
-LRESULT TextField::Edit::OnImeEndComposition(UINT message,
+LRESULT Textfield::Edit::OnImeEndComposition(UINT message,
                                              WPARAM wparam,
                                              LPARAM lparam) {
   // Bug 11863: Korean IMEs send a WM_IME_ENDCOMPOSITION message without
   // sending any WM_IME_COMPOSITION messages when a user deletes all
   // composition characters, i.e. a composition string becomes empty. To handle
   // this case, we need to update the find results when a composition is
   // finished or canceled.
   parent_->SyncText();
   if (parent_->GetController())
     parent_->GetController()->ContentsChanged(parent_, GetText());
   return DefWindowProc(message, wparam, lparam);
 }
 
-void TextField::Edit::OnKeyDown(TCHAR key, UINT repeat_count, UINT flags) {
+void Textfield::Edit::OnKeyDown(TCHAR key, UINT repeat_count, UINT flags) {
   // NOTE: Annoyingly, ctrl-alt-<key> generates WM_KEYDOWN rather than
   // WM_SYSKEYDOWN, so we need to check (flags & KF_ALTDOWN) in various places
   // in this function even with a WM_SYSKEYDOWN handler.
 
   switch (key) {
     case VK_RETURN:
       // If we are multi-line, we want to let returns through so they start a
       // new line.
       if (parent_->IsMultiLine())
         break;
@@ skipping 58 matching lines @@
       // We ignore this event because an IME sends WM_IME_COMPOSITION messages
       // when it updates the CRichEditCtrl text.
       return;
   }
 
   // CRichEditCtrl changes its text on WM_KEYDOWN instead of WM_CHAR for many
   // different keys (backspace, ctrl-v, ...), so we call this in both cases.
   HandleKeystroke(GetCurrentMessage()->message, key, repeat_count, flags);
 }
 
-void TextField::Edit::OnLButtonDblClk(UINT keys, const CPoint& point) {
+void Textfield::Edit::OnLButtonDblClk(UINT keys, const CPoint& point) {
   // Save the double click info for later triple-click detection.
   tracking_double_click_ = true;
   double_click_point_ = point;
   double_click_time_ = GetCurrentMessage()->time;
 
   ScopedFreeze freeze(this, GetTextObjectModel());
   OnBeforePossibleChange();
   DefWindowProc(WM_LBUTTONDBLCLK, keys,
                 MAKELPARAM(ClipXCoordToVisibleText(point.x, false), point.y));
   OnAfterPossibleChange();
 }
 
-void TextField::Edit::OnLButtonDown(UINT keys, const CPoint& point) {
+void Textfield::Edit::OnLButtonDown(UINT keys, const CPoint& point) {
   // Check for triple click, then reset tracker.  Should be safe to subtract
   // double_click_time_ from the current message's time even if the timer has
   // wrapped in between.
   const bool is_triple_click = tracking_double_click_ &&
       win_util::IsDoubleClick(double_click_point_, point,
                               GetCurrentMessage()->time - double_click_time_);
   tracking_double_click_ = false;
 
   ScopedFreeze freeze(this, GetTextObjectModel());
   OnBeforePossibleChange();
   DefWindowProc(WM_LBUTTONDOWN, keys,
                 MAKELPARAM(ClipXCoordToVisibleText(point.x, is_triple_click),
                            point.y));
   OnAfterPossibleChange();
 }
 
-void TextField::Edit::OnLButtonUp(UINT keys, const CPoint& point) {
+void Textfield::Edit::OnLButtonUp(UINT keys, const CPoint& point) {
   ScopedFreeze freeze(this, GetTextObjectModel());
   OnBeforePossibleChange();
   DefWindowProc(WM_LBUTTONUP, keys,
                 MAKELPARAM(ClipXCoordToVisibleText(point.x, false), point.y));
   OnAfterPossibleChange();
 }
 
-void TextField::Edit::OnMouseLeave() {
+void Textfield::Edit::OnMouseLeave() {
   SetContainsMouse(false);
 }
 
-LRESULT TextField::Edit::OnMouseWheel(UINT message,
+LRESULT Textfield::Edit::OnMouseWheel(UINT message,
                                       WPARAM w_param, LPARAM l_param) {
   // Reroute the mouse-wheel to the window under the mouse pointer if
   // applicable.
   if (views::RerouteMouseWheel(m_hWnd, w_param, l_param))
     return 0;
   return DefWindowProc(message, w_param, l_param);;
 }
 
-void TextField::Edit::OnMouseMove(UINT keys, const CPoint& point) {
+void Textfield::Edit::OnMouseMove(UINT keys, const CPoint& point) {
   SetContainsMouse(true);
   // Clamp the selection to the visible text so the user can't drag to select
   // the "phantom newline".  In theory we could achieve this by clipping the X
   // coordinate, but in practice the edit seems to behave nondeterministically
   // with similar sequences of clipped input coordinates fed to it.  Maybe it's
   // reading the mouse cursor position directly?
   //
   // This solution has a minor visual flaw, however: if there's a visible
   // cursor at the edge of the text (only true when there's no selection),
   // dragging the mouse around outside that edge repaints the cursor on every
@@ skipping 33 matching lines @@
     // just a few pixels vertically end up selecting the "phantom newline"...
     // sometimes.
     RECT r;
     GetRect(&r);
     DefWindowProc(WM_MOUSEMOVE, keys,
                   MAKELPARAM(point.x, (r.bottom - r.top) / 2));
     OnAfterPossibleChange();
   }
 }
 
-int TextField::Edit::OnNCCalcSize(BOOL w_param, LPARAM l_param) {
+int Textfield::Edit::OnNCCalcSize(BOOL w_param, LPARAM l_param) {
   content_insets_.Set(0, 0, 0, 0);
   parent_->CalculateInsets(&content_insets_);
   if (w_param) {
     NCCALCSIZE_PARAMS* nc_params =
         reinterpret_cast<NCCALCSIZE_PARAMS*>(l_param);
     nc_params->rgrc[0].left += content_insets_.left();
     nc_params->rgrc[0].right -= content_insets_.right();
     nc_params->rgrc[0].top += content_insets_.top();
     nc_params->rgrc[0].bottom -= content_insets_.bottom();
   } else {
     RECT* rect = reinterpret_cast<RECT*>(l_param);
     rect->left += content_insets_.left();
     rect->right -= content_insets_.right();
     rect->top += content_insets_.top();
     rect->bottom -= content_insets_.bottom();
   }
   return 0;
 }
 
-void TextField::Edit::OnNCPaint(HRGN region) {
+void Textfield::Edit::OnNCPaint(HRGN region) {
   if (!draw_border_)
     return;
 
   HDC hdc = GetWindowDC();
 
   CRect window_rect;
   GetWindowRect(&window_rect);
   // Convert to be relative to 0x0.
   window_rect.MoveToXY(0, 0);
 
@@ skipping 41 matching lines @@
   NativeTheme::instance()->PaintTextField(hdc, part, state, classic_state,
                                           &window_rect, bg_color_, false,
                                           true);
 
   // NOTE: I tried checking the transparent property of the theme and invoking
   // drawParentBackground, but it didn't seem to make a difference.
 
   ReleaseDC(hdc);
 }
 
-void TextField::Edit::OnNonLButtonDown(UINT keys, const CPoint& point) {
+void Textfield::Edit::OnNonLButtonDown(UINT keys, const CPoint& point) {
   // Interestingly, the edit doesn't seem to cancel triple clicking when the
   // x-buttons (which usually means "thumb buttons") are pressed, so we only
   // call this for M and R down.
   tracking_double_click_ = false;
   SetMsgHandled(false);
 }
 
-void TextField::Edit::OnPaste() {
+void Textfield::Edit::OnPaste() {
   if (parent_->IsReadOnly() || !ViewsDelegate::views_delegate)
     return;
 
   Clipboard* clipboard = ViewsDelegate::views_delegate->GetClipboard();
 
   if (!clipboard->IsFormatAvailable(Clipboard::GetPlainTextWFormatType()))
     return;
 
   std::wstring clipboard_str;
   clipboard->ReadText(&clipboard_str);
   if (!clipboard_str.empty()) {
     std::wstring collapsed(CollapseWhitespace(clipboard_str, false));
     if (parent_->GetStyle() & STYLE_LOWERCASE)
       collapsed = l10n_util::ToLower(collapsed);
     // Force a Paste operation to trigger OnContentsChanged, even if identical
     // contents are pasted into the text box.
     text_before_change_.clear();
     ReplaceSel(collapsed.c_str(), true);
   }
 }
 
-void TextField::Edit::OnSysChar(TCHAR ch, UINT repeat_count, UINT flags) {
+void Textfield::Edit::OnSysChar(TCHAR ch, UINT repeat_count, UINT flags) {
   // Nearly all alt-<xxx> combos result in beeping rather than doing something
   // useful, so we discard most.  Exceptions:
   //   * ctrl-alt-<xxx>, which is sometimes important, generates WM_CHAR instead
   //     of WM_SYSCHAR, so it doesn't need to be handled here.
   //   * alt-space gets translated by the default WM_SYSCHAR handler to a
   //     WM_SYSCOMMAND to open the application context menu, so we need to allow
   //     it through.
   if (ch == VK_SPACE)
     SetMsgHandled(false);
 }
 
-void TextField::Edit::HandleKeystroke(UINT message,
+void Textfield::Edit::HandleKeystroke(UINT message,
                                       TCHAR key,
                                       UINT repeat_count,
                                       UINT flags) {
   ScopedFreeze freeze(this, GetTextObjectModel());
 
-  TextField::Controller* controller = parent_->GetController();
+  Textfield::Controller* controller = parent_->GetController();
   bool handled = false;
   if (controller) {
     handled = controller->HandleKeystroke(parent_,
-        TextField::Keystroke(message, key, repeat_count, flags));
+        Textfield::Keystroke(message, key, repeat_count, flags));
   }
 
   if (!handled) {
     OnBeforePossibleChange();
     DefWindowProc(message, key, MAKELPARAM(repeat_count, flags));
     OnAfterPossibleChange();
   }
 }
 
-void TextField::Edit::OnBeforePossibleChange() {
+void Textfield::Edit::OnBeforePossibleChange() {
   // Record our state.
   text_before_change_ = GetText();
 }
 
-void TextField::Edit::OnAfterPossibleChange() {
+void Textfield::Edit::OnAfterPossibleChange() {
   // Prevent the user from selecting the "phantom newline" at the end of the
   // edit.  If they try, we just silently move the end of the selection back to
   // the end of the real text.
   CHARRANGE new_sel;
   GetSel(new_sel);
   const int length = GetTextLength();
   if (new_sel.cpMax > length) {
     new_sel.cpMax = length;
     if (new_sel.cpMin > length)
       new_sel.cpMin = length;
@@ skipping 12 matching lines @@
       ime_composition_length_ = 0;
       if (new_text.empty())
         return;
     }
     parent_->SyncText();
     if (parent_->GetController())
       parent_->GetController()->ContentsChanged(parent_, new_text);
   }
 }
 
-LONG TextField::Edit::ClipXCoordToVisibleText(LONG x,
+LONG Textfield::Edit::ClipXCoordToVisibleText(LONG x,
                                               bool is_triple_click) const {
   // Clip the X coordinate to the left edge of the text.  Careful:
   // PosFromChar(0) may return a negative X coordinate if the beginning of the
   // text has scrolled off the edit, so don't go past the clip rect's edge.
   PARAFORMAT2 pf2;
   GetParaFormat(pf2);
   // Calculation of the clipped coordinate is more complicated if the paragraph
   // layout is RTL layout, or if there is RTL characters inside the LTR layout
   // paragraph.
   bool ltr_text_in_ltr_layout = true;
@@ skipping 35 matching lines @@
   // the end of the text, but triple-click will still work.
   if (x < left_bound) {
     return (is_triple_click && ltr_text_in_ltr_layout) ? left_bound - 1 :
                                                          left_bound;
   }
   if ((length == 0) || (x < right_bound))
     return x;
   return is_triple_click ? (right_bound - 1) : right_bound;
 }
 
-void TextField::Edit::SetContainsMouse(bool contains_mouse) {
+void Textfield::Edit::SetContainsMouse(bool contains_mouse) {
   if (contains_mouse == contains_mouse_)
     return;
 
   contains_mouse_ = contains_mouse;
 
   if (!draw_border_)
     return;
 
   if (contains_mouse_) {
     // Register for notification when the mouse leaves. Need to do this so
     // that we can reset contains mouse properly.
     TRACKMOUSEEVENT tme;
     tme.cbSize = sizeof(tme);
     tme.dwFlags = TME_LEAVE;
     tme.hwndTrack = m_hWnd;
     tme.dwHoverTime = 0;
     TrackMouseEvent(&tme);
   }
   RedrawWindow(NULL, NULL, RDW_INVALIDATE | RDW_FRAME);
 }
 
-ITextDocument* TextField::Edit::GetTextObjectModel() const {
+ITextDocument* Textfield::Edit::GetTextObjectModel() const {
   if (!text_object_model_) {
     CComPtr<IRichEditOle> ole_interface;
     ole_interface.Attach(GetOleInterface());
     text_object_model_ = ole_interface;
   }
   return text_object_model_;
 }
 
 /////////////////////////////////////////////////////////////////////////////
-// TextField
+// Textfield
 
-TextField::~TextField() {
+Textfield::~Textfield() {
   if (edit_) {
     // If the edit hwnd still exists, we need to destroy it explicitly.
     if (*edit_)
       edit_->DestroyWindow();
     delete edit_;
   }
 }
 
-void TextField::ViewHierarchyChanged(bool is_add, View* parent, View* child) {
+void Textfield::ViewHierarchyChanged(bool is_add, View* parent, View* child) {
   Widget* widget;
 
   if (is_add && (widget = GetWidget())) {
     // This notification is called from the AddChildView call below. Ignore it.
     if (native_view_ && !edit_)
       return;
 
     if (!native_view_) {
       native_view_ = new HWNDView();  // Deleted from our superclass destructor
       AddChildView(native_view_);
@@ skipping 16 matching lines @@
       if (!text_.empty())
         edit_->SetText(text_);
       UpdateEditBackgroundColor();
       Layout();
     }
   } else if (!is_add && edit_ && IsWindow(edit_->m_hWnd)) {
     edit_->SetParent(NULL);
   }
 }
 
-void TextField::Layout() {
+void Textfield::Layout() {
   if (native_view_) {
     native_view_->SetBounds(GetLocalBounds(true));
     native_view_->Layout();
   }
 }
 
-gfx::Size TextField::GetPreferredSize() {
+gfx::Size Textfield::GetPreferredSize() {
   gfx::Insets insets;
   CalculateInsets(&insets);
   return gfx::Size(font_.GetExpectedTextWidth(default_width_in_chars_) +
                        insets.width(),
                    num_lines_ * font_.height() + insets.height());
 }
 
-std::wstring TextField::GetText() const {
+std::wstring Textfield::GetText() const {
   return text_;
 }
 
-void TextField::SetText(const std::wstring& text) {
+void Textfield::SetText(const std::wstring& text) {
   text_ = text;
   if (edit_)
     edit_->SetText(text);
 }
 
-void TextField::AppendText(const std::wstring& text) {
+void Textfield::AppendText(const std::wstring& text) {
   text_ += text;
   if (edit_)
     edit_->AppendText(text);
 }
 
-void TextField::CalculateInsets(gfx::Insets* insets) {
+void Textfield::CalculateInsets(gfx::Insets* insets) {
   DCHECK(insets);
 
   if (!draw_border_)
     return;
 
   // NOTE: One would think GetThemeMargins would return the insets we should
   // use, but it doesn't. The margins returned by GetThemeMargins are always
   // 0.
 
   // This appears to be the insets used by Windows.
   insets->Set(3, 3, 3, 3);
 }
 
-void TextField::SyncText() {
+void Textfield::SyncText() {
   if (edit_)
     text_ = edit_->GetText();
 }
 
-void TextField::SetController(Controller* controller) {
+void Textfield::SetController(Controller* controller) {
   controller_ = controller;
 }
 
-TextField::Controller* TextField::GetController() const {
+Textfield::Controller* Textfield::GetController() const {
   return controller_;
 }
 
-bool TextField::IsReadOnly() const {
+bool Textfield::IsReadOnly() const {
   return edit_ ? ((edit_->GetStyle() & ES_READONLY) != 0) : read_only_;
 }
 
-bool TextField::IsPassword() const {
-  return GetStyle() & TextField::STYLE_PASSWORD;
+bool Textfield::IsPassword() const {
+  return GetStyle() & Textfield::STYLE_PASSWORD;
 }
 
-bool TextField::IsMultiLine() const {
+bool Textfield::IsMultiLine() const {
   return (style_ & STYLE_MULTILINE) != 0;
 }
 
-void TextField::SetReadOnly(bool read_only) {
+void Textfield::SetReadOnly(bool read_only) {
   read_only_ = read_only;
   if (edit_) {
     edit_->SetReadOnly(read_only);
     UpdateEditBackgroundColor();
   }
 }
 
-void TextField::Focus() {
+void Textfield::Focus() {
   ::SetFocus(native_view_->GetHWND());
 }
 
-void TextField::SelectAll() {
+void Textfield::SelectAll() {
   if (edit_)
     edit_->SelectAll();
 }
 
-void TextField::ClearSelection() const {
+void Textfield::ClearSelection() const {
   if (edit_)
     edit_->ClearSelection();
 }
 
-HWND TextField::GetNativeComponent() {
+HWND Textfield::GetNativeComponent() {
   return native_view_->GetHWND();
 }
 
-void TextField::SetBackgroundColor(SkColor color) {
+void Textfield::SetBackgroundColor(SkColor color) {
   background_color_ = color;
   use_default_background_color_ = false;
   UpdateEditBackgroundColor();
 }
 
-void TextField::SetDefaultBackgroundColor() {
+void Textfield::SetDefaultBackgroundColor() {
   use_default_background_color_ = true;
   UpdateEditBackgroundColor();
 }
 
-void TextField::SetFont(const gfx::Font& font) {
+void Textfield::SetFont(const gfx::Font& font) {
   font_ = font;
   if (edit_)
     edit_->SetFont(font.hfont());
 }
 
-gfx::Font TextField::GetFont() const {
+gfx::Font Textfield::GetFont() const {
   return font_;
 }
 
-bool TextField::SetHorizontalMargins(int left, int right) {
+bool Textfield::SetHorizontalMargins(int left, int right) {
   // SendMessage expects the two values to be packed into one using MAKELONG
   // so we truncate to 16 bits if necessary.
   return ERROR_SUCCESS == SendMessage(GetNativeComponent(),
                                       (UINT) EM_SETMARGINS,
                                       (WPARAM) EC_LEFTMARGIN | EC_RIGHTMARGIN,
                                       (LPARAM) MAKELONG(left  & 0xFFFF,
                                                         right & 0xFFFF));
 }
 
-void TextField::SetHeightInLines(int num_lines) {
+void Textfield::SetHeightInLines(int num_lines) {
   DCHECK(IsMultiLine());
   num_lines_ = num_lines;
 }
 
-void TextField::RemoveBorder() {
+void Textfield::RemoveBorder() {
   if (!draw_border_)
     return;
 
   draw_border_ = false;
   if (edit_)
     edit_->RemoveBorder();
 }
 
-void TextField::SetEnabled(bool enabled) {
+void Textfield::SetEnabled(bool enabled) {
   View::SetEnabled(enabled);
   edit_->SetEnabled(enabled);
 }
 
-bool TextField::IsFocusable() const {
+bool Textfield::IsFocusable() const {
   return IsEnabled() && !IsReadOnly();
 }
 
-void TextField::AboutToRequestFocusFromTabTraversal(bool reverse) {
+void Textfield::AboutToRequestFocusFromTabTraversal(bool reverse) {
   SelectAll();
 }
 
-bool TextField::SkipDefaultKeyEventProcessing(const KeyEvent& e) {
+bool Textfield::SkipDefaultKeyEventProcessing(const KeyEvent& e) {
   // TODO(hamaji): Figure out which keyboard combinations we need to add here,
   //               similar to LocationBarView::SkipDefaultKeyEventProcessing.
   if (e.GetCharacter() == VK_BACK)
     return true;  // We'll handle BackSpace ourselves.
 
   // We don't translate accelerators for ALT + NumPad digit, they are used for
   // entering special characters.
   if (e.IsAltDown() &&
       win_util::IsNumPadDigit(e.GetCharacter(), e.IsExtendedKey()))
     return true;
 
   return false;
 }
 
-void TextField::UpdateEditBackgroundColor() {
+void Textfield::UpdateEditBackgroundColor() {
   if (!edit_)
     return;
 
   COLORREF bg_color;
   if (!use_default_background_color_)
     bg_color = skia::SkColorToCOLORREF(background_color_);
   else
     bg_color = GetSysColor(read_only_ ? COLOR_3DFACE : COLOR_WINDOW);
   edit_->SetBackgroundColor(bg_color);
 }
 
 }  // namespace views