Remove dead code unnecessarily added by r231563 and 236449

ui/base/ime/remote_input_method_win.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 "ui/base/ime/remote_input_method_win.h"
 
 #include "base/observer_list.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/metro.h"
 #include "base/win/scoped_handle.h"
@@ skipping 90 matching lines @@
   return bounds;
 }
 
 class RemoteInputMethodWin : public InputMethod,
                              public RemoteInputMethodPrivateWin {
  public:
   explicit RemoteInputMethodWin(internal::InputMethodDelegate* delegate)
       : delegate_(delegate),
         remote_delegate_(NULL),
         text_input_client_(NULL),
-        current_input_type_(ui::TEXT_INPUT_TYPE_NONE),
-        current_input_mode_(ui::TEXT_INPUT_MODE_DEFAULT),
         is_candidate_popup_open_(false),
         is_ime_(false),
         langid_(kFallbackLangID) {
     RegisterInstance(this, this);
   }
 
   virtual ~RemoteInputMethodWin() {
     FOR_EACH_OBSERVER(InputMethodObserver,
                       observer_list_,
                       OnInputMethodDestroyed(this));
     UnregisterInstance(this);
   }
 
  private:
   // Overridden from InputMethod:
   virtual void SetDelegate(internal::InputMethodDelegate* delegate) OVERRIDE {
     delegate_ = delegate;
   }
 
   virtual void Init(bool focused) OVERRIDE {
-    if (focused)
-      OnFocus();
   }
 
   virtual void OnFocus() OVERRIDE {
-    FOR_EACH_OBSERVER(InputMethodObserver,
-                      observer_list_,
-                      OnFocus());
   }
 
   virtual void OnBlur() OVERRIDE {
-    FOR_EACH_OBSERVER(InputMethodObserver,
-                      observer_list_,
-                      OnBlur());
   }
 
   virtual bool OnUntranslatedIMEMessage(const base::NativeEvent& event,
                                         NativeEventResult* result) OVERRIDE {
     return false;
   }
 
   virtual void SetFocusedTextInputClient(TextInputClient* client) OVERRIDE {
     std::vector<int32> prev_input_scopes;
     std::swap(input_scopes_, prev_input_scopes);
     std::vector<gfx::Rect> prev_bounds;
     std::swap(composition_character_bounds_, prev_bounds);
     if (client) {
       input_scopes_ = GetInputScopesAsInt(client->GetTextInputType(),
                                           client->GetTextInputMode());
       composition_character_bounds_ = GetCompositionCharacterBounds(client);
-      current_input_type_ = client->GetTextInputType();
-      current_input_mode_ = client->GetTextInputMode();
     }
 
     const bool text_input_client_changed = text_input_client_ != client;
     text_input_client_ = client;
     if (text_input_client_changed) {
       FOR_EACH_OBSERVER(InputMethodObserver,
                         observer_list_,
                         OnTextInputStateChanged(client));
     }
 
@@ skipping 37 matching lines @@
     if (!delegate_)
       return false;
     return delegate_->DispatchFabricatedKeyEventPostIME(event.type(),
                                                         event.key_code(),
                                                         event.flags());
   }
 
   virtual void OnTextInputTypeChanged(const TextInputClient* client) OVERRIDE {
     if (!text_input_client_ || text_input_client_ != client)
       return;
-    const ui::TextInputType prev_type = current_input_type_;
-    const ui::TextInputMode prev_mode = current_input_mode_;
-    current_input_type_ = client->GetTextInputType();
-    current_input_mode_ = client->GetTextInputMode();
-
     std::vector<int32> prev_input_scopes;
     std::swap(input_scopes_, prev_input_scopes);
     input_scopes_ = GetInputScopesAsInt(client->GetTextInputType(),
                                         client->GetTextInputMode());
     if (input_scopes_ != prev_input_scopes && remote_delegate_) {
       remote_delegate_->OnTextInputClientUpdated(
           input_scopes_, composition_character_bounds_);
     }
-    if (current_input_type_ != prev_type || current_input_mode_ != prev_mode) {
-      FOR_EACH_OBSERVER(InputMethodObserver,
-                        observer_list_,
-                        OnTextInputTypeChanged(client));
-    }
   }
 
   virtual void OnCaretBoundsChanged(const TextInputClient* client) OVERRIDE {
     if (!text_input_client_ || text_input_client_ != client)
       return;
     std::vector<gfx::Rect> prev_rects;
     std::swap(composition_character_bounds_, prev_rects);
     composition_character_bounds_ = GetCompositionCharacterBounds(client);
     if (composition_character_bounds_ != prev_rects && remote_delegate_) {
       remote_delegate_->OnTextInputClientUpdated(
           input_scopes_, composition_character_bounds_);
     }
-    FOR_EACH_OBSERVER(InputMethodObserver,
-                      observer_list_,
-                      OnCaretBoundsChanged(client));
   }
 
   virtual void CancelComposition(const TextInputClient* client) OVERRIDE {
     if (CanSendRemoteNotification(client))
       remote_delegate_->CancelComposition();
   }
 
   virtual void OnInputLocaleChanged() OVERRIDE {
   }
 
@@ skipping 105 matching lines @@
            text_input_client_ == text_input_client &&
            remote_delegate_;
   }
 
   ObserverList<InputMethodObserver> observer_list_;
 
   internal::InputMethodDelegate* delegate_;
   internal::RemoteInputMethodDelegateWin* remote_delegate_;
 
   TextInputClient* text_input_client_;
-  ui::TextInputType current_input_type_;
-  ui::TextInputMode current_input_mode_;
   std::vector<int32> input_scopes_;
   std::vector<gfx::Rect> composition_character_bounds_;
   bool is_candidate_popup_open_;
   bool is_ime_;
   LANGID langid_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoteInputMethodWin);
 };
 
 }  // namespace
@@ skipping 16 matching lines @@
   return scoped_ptr<InputMethod>(new RemoteInputMethodWin(delegate));
 }
 
 // static
 RemoteInputMethodPrivateWin* RemoteInputMethodPrivateWin::Get(
     InputMethod* input_method) {
   return GetPrivate(input_method);
 }
 
 }  // namespace ui