Moving notification types which are chrome specific to a new header file chrome_notification_type...

chrome/browser/ui/touch/frame/touch_browser_frame_view.cc

 // Copyright (c) 2011 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/touch/frame/touch_browser_frame_view.h"
 
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_host/render_widget_host_view_views.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/browser/ui/touch/frame/keyboard_container_view.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/tab_contents/tab_contents_view_touch.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/tab_contents/navigation_controller.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/browser/tab_contents/tab_contents_view.h"
+#include "content/common/content_notification_types.h"
 #include "content/common/notification_service.h"
-#include "content/common/notification_type.h"
 #include "content/common/view_messages.h"
 #include "ui/base/animation/slide_animation.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/transform.h"
 #include "views/controls/button/image_button.h"
 #include "views/controls/textfield/textfield.h"
 #include "views/focus/focus_manager.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/input_method/virtual_keyboard_selector.h"
@@ skipping 24 matching lines @@
 // TouchBrowserFrameView, public:
 
 TouchBrowserFrameView::TouchBrowserFrameView(BrowserFrame* frame,
                                              BrowserView* browser_view)
     : OpaqueBrowserFrameView(frame, browser_view),
       keyboard_showing_(false),
       keyboard_height_(kDefaultKeyboardHeight),
       focus_listener_added_(false),
       keyboard_(NULL) {
   registrar_.Add(this,
-                 NotificationType::NAV_ENTRY_COMMITTED,
+                 chrome::NAV_ENTRY_COMMITTED,
                  NotificationService::AllSources());
   registrar_.Add(this,
-                 NotificationType::FOCUS_CHANGED_IN_PAGE,
+                 chrome::FOCUS_CHANGED_IN_PAGE,
                  NotificationService::AllSources());
   registrar_.Add(this,
-                 NotificationType::TAB_CONTENTS_DESTROYED,
+                 chrome::TAB_CONTENTS_DESTROYED,
                  NotificationService::AllSources());
   registrar_.Add(this,
-                 NotificationType::HIDE_KEYBOARD_INVOKED,
+                 chrome::HIDE_KEYBOARD_INVOKED,
                  NotificationService::AllSources());
   registrar_.Add(this,
-                 NotificationType::SET_KEYBOARD_HEIGHT_INVOKED,
+                 chrome::SET_KEYBOARD_HEIGHT_INVOKED,
                  NotificationService::AllSources());
   registrar_.Add(this,
-                 NotificationType::EDITABLE_ELEMENT_TOUCHED,
+                 chrome::EDITABLE_ELEMENT_TOUCHED,
                  NotificationService::AllSources());
 
   browser_view->browser()->tabstrip_model()->AddObserver(this);
 
   animation_.reset(new ui::SlideAnimation(this));
   animation_->SetTweenType(ui::Tween::LINEAR);
   animation_->SetSlideDuration(kKeyboardSlideDuration);
 
 #if defined(OS_CHROMEOS)
   chromeos::input_method::InputMethodManager* manager =
@@ skipping 162 matching lines @@
 }
 
 void TouchBrowserFrameView::TabStripEmpty() {
   if (animation_->is_animating()) {
     // Reset the delegate so the AnimationEnded callback doesn't trigger.
     animation_->set_delegate(NULL);
     animation_->Stop();
   }
 }
 
-void TouchBrowserFrameView::Observe(NotificationType type,
+void TouchBrowserFrameView::Observe(int type,
                                     const NotificationSource& source,
                                     const NotificationDetails& details) {
   Browser* browser = browser_view()->browser();
-  if (type == NotificationType::FOCUS_CHANGED_IN_PAGE) {
+  if (type == chrome::FOCUS_CHANGED_IN_PAGE) {
     // Only modify the keyboard state if the currently active tab sent the
     // notification.
     const TabContents* current_tab = browser->GetSelectedTabContents();
     TabContents* source_tab = Source<TabContents>(source).ptr();
     const bool editable = *Details<const bool>(details).ptr();
 
     if (current_tab == source_tab && TabContentsHasFocus(source_tab))
       UpdateKeyboardAndLayout(editable);
 
     // Save the state of the focused field so that the keyboard visibility
     // can be determined after tab switching.
     GetFocusedStateAccessor()->SetProperty(
         source_tab->property_bag(), editable);
-  } else if (type == NotificationType::NAV_ENTRY_COMMITTED) {
+  } else if (type == chrome::NAV_ENTRY_COMMITTED) {
     NavigationController* controller =
         Source<NavigationController>(source).ptr();
     Browser* source_browser = Browser::GetBrowserForController(
         controller, NULL);
 
     // If the Browser for the keyboard has navigated, re-evaluate the visibility
     // of the keyboard.
     TouchBrowserFrameView::VirtualKeyboardType keyboard_type = NONE;
     views::View* view = GetFocusManager()->GetFocusedView();
     if (view) {
       if (view->GetClassName() == views::Textfield::kViewClassName)
         keyboard_type = GENERIC;
       if (view->GetClassName() == RenderWidgetHostViewViews::kViewClassName) {
         // Reset the state of the focused field in the current tab.
         GetFocusedStateAccessor()->SetProperty(
             controller->tab_contents()->property_bag(), false);
       }
     }
     if (source_browser == browser)
       UpdateKeyboardAndLayout(keyboard_type == GENERIC);
-  } else if (type == NotificationType::TAB_CONTENTS_DESTROYED) {
+  } else if (type == chrome::TAB_CONTENTS_DESTROYED) {
     GetFocusedStateAccessor()->DeleteProperty(
         Source<TabContents>(source).ptr()->property_bag());
-  } else if (type == NotificationType::PREF_CHANGED) {
+  } else if (type == chrome::PREF_CHANGED) {
     OpaqueBrowserFrameView::Observe(type, source, details);
-  } else if (type == NotificationType::HIDE_KEYBOARD_INVOKED) {
+  } else if (type == chrome::HIDE_KEYBOARD_INVOKED) {
     TabContents* tab_contents =
         browser_view()->browser()->GetSelectedTabContents();
     if (tab_contents) {
       GetFocusedStateAccessor()->SetProperty(tab_contents->property_bag(),
                                              false);
     }
     UpdateKeyboardAndLayout(false);
-  } else if (type == NotificationType::SET_KEYBOARD_HEIGHT_INVOKED) {
+  } else if (type == chrome::SET_KEYBOARD_HEIGHT_INVOKED) {
     // TODO(penghuang) Allow extension conrtol the virtual keyboard directly
     // instead of using Notification.
     int height = *reinterpret_cast<int*>(details.map_key());
     if (height != keyboard_height_) {
       DCHECK_GE(height, 0) << "Height of the keyboard is less than 0.";
       DCHECK_LE(height, View::height()) << "Height of the keyboard is greater "
         "than the height of frame view.";
       keyboard_height_ = height;
       parent()->Layout();
     }
-  } else if (type == NotificationType::EDITABLE_ELEMENT_TOUCHED) {
+  } else if (type == chrome::EDITABLE_ELEMENT_TOUCHED) {
     UpdateKeyboardAndLayout(true);
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // ui::AnimationDelegate implementation
 void TouchBrowserFrameView::AnimationProgressed(const ui::Animation* anim) {
   ui::Transform transform;
   transform.SetTranslateY(
       ui::Tween::ValueBetween(anim->GetCurrentValue(), keyboard_height_, 0));
@@ skipping 29 matching lines @@
     const chromeos::input_method::VirtualKeyboard& virtual_keyboard,
     const std::string& virtual_keyboard_layout) {
   if (!keyboard_)
     return;
 
   const GURL& url = virtual_keyboard.GetURLForLayout(virtual_keyboard_layout);
   keyboard_->LoadURL(url);
   VLOG(1) << "VirtualKeyboardChanged: Switched to " << url.spec();
 }
 #endif