Move webNavigation extension api into a separate directory

chrome/browser/extensions/api/web_navigation/web_navigation_api.h

 // 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.
 
 // Defines the Chrome Extensions WebNavigation API functions for observing and
 // intercepting navigation events, as specified in the extension JSON API.
 
-#ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_WEBNAVIGATION_API_H_
-#define CHROME_BROWSER_EXTENSIONS_EXTENSION_WEBNAVIGATION_API_H_
+#ifndef CHROME_BROWSER_EXTENSIONS_API_WEB_NAVIGATION_WEB_NAVIGATION_API_H_
+#define CHROME_BROWSER_EXTENSIONS_API_WEB_NAVIGATION_WEB_NAVIGATION_API_H_
 #pragma once
 
 #include <map>
 #include <set>
 
 #include "base/compiler_specific.h"
 #include "chrome/browser/extensions/extension_function.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "googleurl/src/gurl.h"
 
 struct RetargetingDetails;
 
+namespace extensions {
+
 // Tracks the navigation state of all frames in a given tab currently known to
 // the webNavigation API. It is mainly used to track in which frames an error
 // occurred so no further events for this frame are being sent.
 class FrameNavigationState {
  public:
   typedef std::set<int64>::const_iterator const_iterator;
 
   FrameNavigationState();
   ~FrameNavigationState();
 
@@ skipping 82 matching lines @@
   // The current main frame.
   int64 main_frame_id_;
 
   // If true, also allow events from chrome-extension:// URLs.
   static bool allow_extension_scheme_;
 
   DISALLOW_COPY_AND_ASSIGN(FrameNavigationState);
 };
 
 // Tab contents observer that forwards navigation events to the event router.
-class ExtensionWebNavigationTabObserver : public content::NotificationObserver,
-                                          public content::WebContentsObserver {
+class WebNavigationTabObserver : public content::NotificationObserver,
+                                 public content::WebContentsObserver {
  public:
-  explicit ExtensionWebNavigationTabObserver(
-      content::WebContents* web_contents);
-  virtual ~ExtensionWebNavigationTabObserver();
+  explicit WebNavigationTabObserver(content::WebContents* web_contents);
+  virtual ~WebNavigationTabObserver();
 
   // Returns the object for the given |tab_contents|.
-  static ExtensionWebNavigationTabObserver* Get(
-      content::WebContents* web_contents);
+  static WebNavigationTabObserver* Get(content::WebContents* web_contents);
 
   const FrameNavigationState& frame_navigation_state() const {
     return navigation_state_;
   }
 
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
@@ skipping 32 matching lines @@
   // True if the transition and target url correspond to a reference fragment
   // navigation.
   bool IsReferenceFragmentNavigation(int64 frame_id, const GURL& url);
 
   // Tracks the state of the frames we are sending events for.
   FrameNavigationState navigation_state_;
 
   // Used for tracking registrations to redirect notifications.
   content::NotificationRegistrar registrar_;
 
-  DISALLOW_COPY_AND_ASSIGN(ExtensionWebNavigationTabObserver);
+  DISALLOW_COPY_AND_ASSIGN(WebNavigationTabObserver);
 };
 
 // Observes navigation notifications and routes them as events to the extension
 // system.
-class ExtensionWebNavigationEventRouter : public content::NotificationObserver {
+class WebNavigationEventRouter : public content::NotificationObserver {
  public:
-  explicit ExtensionWebNavigationEventRouter(Profile* profile);
-  virtual ~ExtensionWebNavigationEventRouter();
+  explicit WebNavigationEventRouter(Profile* profile);
+  virtual ~WebNavigationEventRouter();
 
   // Invoked by the extensions service once the extension system is fully set
   // up and can start dispatching events to extensions.
   void Init();
 
  private:
   // Used to cache the information about newly created WebContents objects.
   struct PendingWebContents{
     PendingWebContents();
     PendingWebContents(content::WebContents* source_web_contents,
@@ skipping 31 matching lines @@
   // Mapping pointers to WebContents objects to information about how they got
   // created.
   std::map<content::WebContents*, PendingWebContents> pending_web_contents_;
 
   // Used for tracking registrations to navigation notifications.
   content::NotificationRegistrar registrar_;
 
   // The profile that owns us via ExtensionService.
   Profile* profile_;
 
-  DISALLOW_COPY_AND_ASSIGN(ExtensionWebNavigationEventRouter);
+  DISALLOW_COPY_AND_ASSIGN(WebNavigationEventRouter);
 };
 
 // API function that returns the state of a given frame.
 class GetFrameFunction : public SyncExtensionFunction {
   virtual ~GetFrameFunction() {}
   virtual bool RunImpl() OVERRIDE;
   DECLARE_EXTENSION_FUNCTION_NAME("webNavigation.getFrame")
 };
 
 // API function that returns the states of all frames in a given tab.
 class GetAllFramesFunction : public SyncExtensionFunction {
   virtual ~GetAllFramesFunction() {}
   virtual bool RunImpl() OVERRIDE;
   DECLARE_EXTENSION_FUNCTION_NAME("webNavigation.getAllFrames")
 };
 
-#endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_WEBNAVIGATION_API_H_
+}  // namespace extensions
+
+#endif  // CHROME_BROWSER_EXTENSIONS_API_WEB_NAVIGATION_WEB_NAVIGATION_API_H_