Convert more users away from DOMView.

chrome/browser/ui/virtual_keyboard/virtual_keyboard_manager.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 "chrome/browser/ui/virtual_keyboard/virtual_keyboard_manager.h"
 
 #include "base/json/json_writer.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_event_router.h"
 #include "chrome/browser/extensions/extension_function_dispatcher.h"
@@ skipping 136 matching lines @@
   virtual void OnWidgetClosing(Widget* widget) OVERRIDE;
   virtual void OnWidgetVisibilityChanged(Widget* widget, bool visible) OVERRIDE;
   virtual void OnWidgetActivationChanged(Widget* widget, bool active) OVERRIDE;
 
   // The animation.
   scoped_ptr<ui::SlideAnimation> animation_;
 
   GURL keyboard_url_;
 
   // The WebView to host the keyboard.
-  views::WebView* webview_;
+  views::WebView* web_view_;
 
   ExtensionFunctionDispatcher extension_dispatcher_;
 
   // The widget the events from the keyboard should be directed to.
   views::Widget* target_;
 
   // Height of the keyboard.
   int keyboard_height_;
 
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(KeyboardWidget);
 };
 
 KeyboardWidget::KeyboardWidget()
     : views::Widget::Widget(),
       keyboard_url_(chrome::kChromeUIKeyboardURL),
-      webview_(new DOMView(ProfileManager::GetDefaultProfile()))),
+      web_view_(new views::WebView(ProfileManager::GetDefaultProfile()))),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           extension_dispatcher_(ProfileManager::GetDefaultProfile(), this)),
       target_(NULL),
       keyboard_height_(kDefaultKeyboardHeight) {
 
   // Initialize the widget first.
   views::Widget::InitParams params(views::Widget::InitParams::TYPE_POPUP);
   params.keep_on_top = true;
   params.transparent = true;
   params.bounds = GetKeyboardPosition(keyboard_height_);
 #if defined(USE_AURA)
   params.parent = ash::Shell::GetInstance()->GetContainer(
       ash::internal::kShellWindowId_MenuContainer);
 #endif
   Init(params);
 
   // Setup the DOM view to host the keyboard.
-  webview_->CreateWebContentsWithSiteInstance(
-      content::SiteInstance::CreateForURL(webview_->browser_context(),
+  web_view_->CreateWebContentsWithSiteInstance(
+      content::SiteInstance::CreateForURL(web_view_->browser_context(),
                                           keyboard_url_));
-  webview_->LoadInitialURL(keyboard_url_);
-  SetContentsView(webview_);
+  web_view_->LoadInitialURL(keyboard_url_);
+  SetContentsView(web_view_);
 
   // Setup observer so the events from the keyboard can be handled.
-  content::WebContentsObserver::Observe(webview_->web_contents());
+  content::WebContentsObserver::Observe(web_view_->web_contents());
 
   // Initialize the animation.
   animation_.reset(new ui::SlideAnimation(this));
   animation_->SetTweenType(ui::Tween::LINEAR);
   animation_->SetSlideDuration(kKeyboardSlideDuration);
 
   views::TextInputTypeTracker::GetInstance()->AddTextInputTypeObserver(this);
   registrar_.Add(this,
                  chrome::NOTIFICATION_FOCUSED_EDITABLE_NODE_TOUCHED,
                  content::NotificationService::AllSources());
@@ skipping 124 matching lines @@
   IPC_BEGIN_MESSAGE_MAP(KeyboardWidget, message)
     IPC_MESSAGE_HANDLER(ExtensionHostMsg_Request, OnRequest)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void KeyboardWidget::RenderViewGone(base::TerminationStatus status) {
   if (status != base::TERMINATION_STATUS_NORMAL_TERMINATION) {
     // Reload the keyboard if it crashes.
-    webview_->LoadInitialURL(keyboard_url_);
-    webview_->SchedulePaint();
+    web_view_->LoadInitialURL(keyboard_url_);
+    web_view_->SchedulePaint();
   }
 }
 
 void KeyboardWidget::OnRequest(const ExtensionHostMsg_Request_Params& request) {
-  extension_dispatcher_.Dispatch(request,
-                                 webview_->web_contents()->GetRenderViewHost());
+  extension_dispatcher_.Dispatch(
+      request,
+      web_view_->web_contents()->GetRenderViewHost());
 }
 
 void KeyboardWidget::TextInputTypeChanged(ui::TextInputType type,
                                           views::Widget *widget) {
   // Send onTextInputTypeChanged event to keyboard extension.
   ListValue args;
   switch (type) {
     case ui::TEXT_INPUT_TYPE_NONE: {
       args.Append(Value::CreateStringValue("none"));
       break;
@@ skipping 29 matching lines @@
     default: {
       NOTREACHED();
       args.Append(Value::CreateStringValue("none"));
       break;
     }
   }
 
   std::string json_args;
   base::JSONWriter::Write(&args, &json_args);
 
-  Profile* profile = Profile::FromBrowserContext(webview_->browser_context());
+  Profile* profile = Profile::FromBrowserContext(web_view_->browser_context());
   profile->GetExtensionEventRouter()->DispatchEventToRenderers(
       kOnTextInputTypeChanged, json_args, NULL, GURL());
 
   if (type == ui::TEXT_INPUT_TYPE_NONE)
     Hide();
   else
     ShowKeyboardForWidget(widget);
 }
 
 Browser* KeyboardWidget::GetBrowser() {
   // TODO(sad): Find a better way. Perhaps just return NULL, and fix
   // SendKeyboardEventInputFunction::GetTopLevelWidget to somehow interact with
   // the WM to find the top level widget?
   return BrowserList::GetLastActive();
 }
 
 content::WebContents* KeyboardWidget::GetAssociatedWebContents() const {
-  return webview_->web_contents();
+  return web_view_->web_contents();
 }
 
 #if defined(OS_CHROMEOS)
 void KeyboardWidget::VirtualKeyboardChanged(
     chromeos::input_method::InputMethodManager* manager,
     const chromeos::input_method::VirtualKeyboard& virtual_keyboard,
     const std::string& virtual_keyboard_layout) {
   const GURL& url = virtual_keyboard.GetURLForLayout(virtual_keyboard_layout);
-  webview_->LoadInitialURL(url);
+  web_view_->LoadInitialURL(url);
   VLOG(1) << "VirtualKeyboardChanged: Switched to " << url.spec();
 }
 #endif
 
 #if defined(USE_AURA)
 void KeyboardWidget::OnRootWindowResized(const aura::RootWindow* root,
                                          const gfx::Size& old_size) {
   ResetBounds();
 }
 #endif
@@ skipping 87 matching lines @@
 
 void VirtualKeyboardManager::OnWidgetClosing(views::Widget* widget) {
   DCHECK_EQ(keyboard_, widget);
   keyboard_ = NULL;
 }
 
 // static
 VirtualKeyboardManager* VirtualKeyboardManager::GetInstance() {
   return Singleton<VirtualKeyboardManager>::get();
 }