Move webNavigation extension api into a separate directory

chrome/browser/extensions/api/web_navigation/web_navigation_api.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.
 
 // Implements the Chrome Extensions WebNavigation API.
 
-#include "chrome/browser/extensions/extension_webnavigation_api.h"
+#include "chrome/browser/extensions/api/web_navigation/web_navigation_api.h"
 
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/string_number_conversions.h"
 #include "base/time.h"
 #include "base/values.h"
+#include "chrome/browser/extensions/api/web_navigation/web_navigation_api_constants.h"
 #include "chrome/browser/extensions/extension_event_router.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
-#include "chrome/browser/extensions/extension_webnavigation_api_constants.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/tab_contents/retargeting_details.h"
 #include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/resource_request_details.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_view_host_delegate.h"
 #include "content/public/browser/web_contents.h"
 #include "net/base/net_errors.h"
 
-namespace keys = extension_webnavigation_api_constants;
-
 using content::BrowserContext;
 using content::ResourceRedirectDetails;
 using content::WebContents;
 
+namespace extensions {
+
+namespace keys = web_navigation_api_constants;
+
 namespace {
 
-typedef std::map<WebContents*, ExtensionWebNavigationTabObserver*>
-    TabObserverMap;
+typedef std::map<WebContents*, WebNavigationTabObserver*> TabObserverMap;
 static base::LazyInstance<TabObserverMap> g_tab_observer =
     LAZY_INSTANCE_INITIALIZER;
 
 // URL schemes for which we'll send events.
 const char* kValidSchemes[] = {
   chrome::kHttpScheme,
   chrome::kHttpsScheme,
   chrome::kFileScheme,
   chrome::kFtpScheme,
   chrome::kJavaScriptScheme,
@@ skipping 308 matching lines @@
 }
 
 bool FrameNavigationState::GetIsServerRedirected(int64 frame_id) const {
   FrameIdToStateMap::const_iterator frame_state =
       frame_state_map_.find(frame_id);
   return (frame_state != frame_state_map_.end() &&
           frame_state->second.is_server_redirected);
 }
 
 
-// ExtensionWebNavigtionEventRouter -------------------------------------------
+// WebNavigtionEventRouter -------------------------------------------
 
-ExtensionWebNavigationEventRouter::PendingWebContents::PendingWebContents()
+WebNavigationEventRouter::PendingWebContents::PendingWebContents()
     : source_web_contents(NULL),
       source_frame_id(0),
       source_frame_is_main_frame(false),
       target_web_contents(NULL),
       target_url() {
 }
 
-ExtensionWebNavigationEventRouter::PendingWebContents::PendingWebContents(
+WebNavigationEventRouter::PendingWebContents::PendingWebContents(
     WebContents* source_web_contents,
     int64 source_frame_id,
     bool source_frame_is_main_frame,
     WebContents* target_web_contents,
     const GURL& target_url)
     : source_web_contents(source_web_contents),
       source_frame_id(source_frame_id),
       source_frame_is_main_frame(source_frame_is_main_frame),
       target_web_contents(target_web_contents),
       target_url(target_url) {
 }
 
-ExtensionWebNavigationEventRouter::PendingWebContents::~PendingWebContents() {}
+WebNavigationEventRouter::PendingWebContents::~PendingWebContents() {}
 
-ExtensionWebNavigationEventRouter::ExtensionWebNavigationEventRouter(
-    Profile* profile) : profile_(profile) {}
+WebNavigationEventRouter::WebNavigationEventRouter(Profile* profile)
+    : profile_(profile) {}
 
-ExtensionWebNavigationEventRouter::~ExtensionWebNavigationEventRouter() {}
+WebNavigationEventRouter::~WebNavigationEventRouter() {}
 
-void ExtensionWebNavigationEventRouter::Init() {
+void WebNavigationEventRouter::Init() {
   if (registrar_.IsEmpty()) {
     registrar_.Add(this,
                    chrome::NOTIFICATION_RETARGETING,
                    content::NotificationService::AllSources());
     registrar_.Add(this,
                    content::NOTIFICATION_TAB_ADDED,
                    content::NotificationService::AllSources());
     registrar_.Add(this,
                    content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
                    content::NotificationService::AllSources());
   }
 }
 
-void ExtensionWebNavigationEventRouter::Observe(
+void WebNavigationEventRouter::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_RETARGETING: {
       Profile* profile = content::Source<Profile>(source).ptr();
       if (profile->GetOriginalProfile() == profile_) {
         Retargeting(
             content::Details<const RetargetingDetails>(details).ptr());
       }
       break;
     }
 
     case content::NOTIFICATION_TAB_ADDED:
       TabAdded(content::Details<WebContents>(details).ptr());
       break;
 
     case content::NOTIFICATION_WEB_CONTENTS_DESTROYED:
       TabDestroyed(content::Source<WebContents>(source).ptr());
       break;
 
     default:
       NOTREACHED();
   }
 }
 
-void ExtensionWebNavigationEventRouter::Retargeting(
-    const RetargetingDetails* details) {
+void WebNavigationEventRouter::Retargeting(const RetargetingDetails* details) {
   if (details->source_frame_id == 0)
     return;
-  ExtensionWebNavigationTabObserver* tab_observer =
-      ExtensionWebNavigationTabObserver::Get(details->source_web_contents);
+  WebNavigationTabObserver* tab_observer =
+      WebNavigationTabObserver::Get(details->source_web_contents);
   if (!tab_observer) {
     // If you hit this DCHECK(), please add reproduction steps to
     // http://crbug.com/109464.
     DCHECK(details->source_web_contents->GetViewType() !=
            content::VIEW_TYPE_TAB_CONTENTS);
     return;
   }
   const FrameNavigationState& frame_navigation_state =
       tab_observer->frame_navigation_state();
 
@@ skipping 18 matching lines @@
     DispatchOnCreatedNavigationTarget(
         details->source_web_contents,
         details->target_web_contents->GetBrowserContext(),
         details->source_frame_id,
         frame_navigation_state.IsMainFrame(details->source_frame_id),
         details->target_web_contents,
         details->target_url);
   }
 }
 
-void ExtensionWebNavigationEventRouter::TabAdded(WebContents* tab) {
+void WebNavigationEventRouter::TabAdded(WebContents* tab) {
   std::map<WebContents*, PendingWebContents>::iterator iter =
       pending_web_contents_.find(tab);
   if (iter == pending_web_contents_.end())
     return;
 
   DispatchOnCreatedNavigationTarget(
       iter->second.source_web_contents,
       iter->second.target_web_contents->GetBrowserContext(),
       iter->second.source_frame_id,
       iter->second.source_frame_is_main_frame,
       iter->second.target_web_contents,
       iter->second.target_url);
   pending_web_contents_.erase(iter);
 }
 
-void ExtensionWebNavigationEventRouter::TabDestroyed(WebContents* tab) {
+void WebNavigationEventRouter::TabDestroyed(WebContents* tab) {
   pending_web_contents_.erase(tab);
   for (std::map<WebContents*, PendingWebContents>::iterator i =
            pending_web_contents_.begin(); i != pending_web_contents_.end(); ) {
     if (i->second.source_web_contents == tab)
       pending_web_contents_.erase(i++);
     else
       ++i;
   }
 }
 
-// ExtensionWebNavigationTabObserver ------------------------------------------
+// WebNavigationTabObserver ------------------------------------------
 
-ExtensionWebNavigationTabObserver::ExtensionWebNavigationTabObserver(
-    WebContents* web_contents)
+WebNavigationTabObserver::WebNavigationTabObserver(WebContents* web_contents)
     : WebContentsObserver(web_contents) {
   g_tab_observer.Get().insert(TabObserverMap::value_type(web_contents, this));
   registrar_.Add(this,
                  content::NOTIFICATION_RESOURCE_RECEIVED_REDIRECT,
                  content::Source<WebContents>(web_contents));
 }
 
-ExtensionWebNavigationTabObserver::~ExtensionWebNavigationTabObserver() {}
+WebNavigationTabObserver::~WebNavigationTabObserver() {}
 
 // static
-ExtensionWebNavigationTabObserver* ExtensionWebNavigationTabObserver::Get(
+WebNavigationTabObserver* WebNavigationTabObserver::Get(
     WebContents* web_contents) {
   TabObserverMap::iterator i = g_tab_observer.Get().find(web_contents);
   return i == g_tab_observer.Get().end() ? NULL : i->second;
 }
 
-void ExtensionWebNavigationTabObserver::Observe(
+void WebNavigationTabObserver::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case content::NOTIFICATION_RESOURCE_RECEIVED_REDIRECT: {
       ResourceRedirectDetails* resource_redirect_details =
           content::Details<ResourceRedirectDetails>(details).ptr();
       ResourceType::Type resource_type =
           resource_redirect_details->resource_type;
       if (resource_type == ResourceType::MAIN_FRAME ||
           resource_type == ResourceType::SUB_FRAME) {
         int64 frame_id = resource_redirect_details->frame_id;
         if (!navigation_state_.CanSendEvents(frame_id))
           return;
         navigation_state_.SetIsServerRedirected(frame_id);
       }
       break;
     }
 
     default:
       NOTREACHED();
   }
 }
 
-void ExtensionWebNavigationTabObserver::DidStartProvisionalLoadForFrame(
+void WebNavigationTabObserver::DidStartProvisionalLoadForFrame(
     int64 frame_id,
     bool is_main_frame,
     const GURL& validated_url,
     bool is_error_page,
     content::RenderViewHost* render_view_host) {
   // Ignore navigations of sub frames, if the main frame isn't committed yet.
   // This might happen if a sub frame triggers a navigation for both the main
   // frame and itself. Since the sub frame is about to be deleted, and there's
   // no way for an extension to tell that these navigations belong to an old
   // frame, we just suppress the events here.
   int64 main_frame_id = navigation_state_.GetMainFrameID();
   if (!is_main_frame &&
       !navigation_state_.GetNavigationCommitted(main_frame_id)) {
     return;
   }
 
   navigation_state_.TrackFrame(frame_id,
                                validated_url,
                                is_main_frame,
                                is_error_page);
   if (!navigation_state_.CanSendEvents(frame_id))
     return;
   DispatchOnBeforeNavigate(
       web_contents(), frame_id, is_main_frame, validated_url);
 }
 
-void ExtensionWebNavigationTabObserver::DidCommitProvisionalLoadForFrame(
+void WebNavigationTabObserver::DidCommitProvisionalLoadForFrame(
     int64 frame_id,
     bool is_main_frame,
     const GURL& url,
     content::PageTransition transition_type) {
   if (!navigation_state_.CanSendEvents(frame_id))
     return;
 
   bool is_reference_fragment_navigation =
       IsReferenceFragmentNavigation(frame_id, url);
 
@@ skipping 18 matching lines @@
     DispatchOnCommitted(
         keys::kOnCommitted,
         web_contents(),
         frame_id,
         is_main_frame,
         url,
         transition_type);
   }
 }
 
-void ExtensionWebNavigationTabObserver::DidFailProvisionalLoad(
+void WebNavigationTabObserver::DidFailProvisionalLoad(
     int64 frame_id,
     bool is_main_frame,
     const GURL& validated_url,
     int error_code,
     const string16& error_description) {
   if (!navigation_state_.CanSendEvents(frame_id))
     return;
   navigation_state_.SetErrorOccurredInFrame(frame_id);
   DispatchOnErrorOccurred(
       web_contents(), validated_url, frame_id, is_main_frame, error_code);
 }
 
-void ExtensionWebNavigationTabObserver::DocumentLoadedInFrame(
+void WebNavigationTabObserver::DocumentLoadedInFrame(
     int64 frame_id) {
   if (!navigation_state_.CanSendEvents(frame_id))
     return;
   DispatchOnDOMContentLoaded(web_contents(),
                              navigation_state_.GetUrl(frame_id),
                              navigation_state_.IsMainFrame(frame_id),
                              frame_id);
 }
 
-void ExtensionWebNavigationTabObserver::DidFinishLoad(
+void WebNavigationTabObserver::DidFinishLoad(
     int64 frame_id,
     const GURL& validated_url,
     bool is_main_frame) {
   if (!navigation_state_.CanSendEvents(frame_id))
     return;
   navigation_state_.SetNavigationCompleted(frame_id);
   DCHECK_EQ(navigation_state_.GetUrl(frame_id), validated_url);
   DCHECK_EQ(navigation_state_.IsMainFrame(frame_id), is_main_frame);
   DispatchOnCompleted(web_contents(),
                       validated_url,
                       is_main_frame,
                       frame_id);
 }
 
-void ExtensionWebNavigationTabObserver::DidOpenRequestedURL(
+void WebNavigationTabObserver::DidOpenRequestedURL(
     WebContents* new_contents,
     const GURL& url,
     const content::Referrer& referrer,
     WindowOpenDisposition disposition,
     content::PageTransition transition,
     int64 source_frame_id) {
   if (!navigation_state_.CanSendEvents(source_frame_id))
     return;
 
   // We only send the onCreatedNavigationTarget if we end up creating a new
   // window.
   if (disposition != SINGLETON_TAB &&
       disposition != NEW_FOREGROUND_TAB &&
       disposition != NEW_BACKGROUND_TAB &&
       disposition != NEW_POPUP &&
       disposition != NEW_WINDOW &&
       disposition != OFF_THE_RECORD)
     return;
 
   DispatchOnCreatedNavigationTarget(
       web_contents(),
       new_contents->GetBrowserContext(),
       source_frame_id,
       navigation_state_.IsMainFrame(source_frame_id),
       new_contents,
       url);
 }
 
-void ExtensionWebNavigationTabObserver::WebContentsDestroyed(WebContents* tab) {
+void WebNavigationTabObserver::WebContentsDestroyed(WebContents* tab) {
   g_tab_observer.Get().erase(tab);
   for (FrameNavigationState::const_iterator frame = navigation_state_.begin();
        frame != navigation_state_.end(); ++frame) {
     if (!navigation_state_.GetNavigationCompleted(*frame) &&
         navigation_state_.CanSendEvents(*frame)) {
       DispatchOnErrorOccurred(
         tab,
         navigation_state_.GetUrl(*frame),
         *frame,
         navigation_state_.IsMainFrame(*frame),
         net::ERR_ABORTED);
     }
   }
 }
 
 // See also NavigationController::IsURLInPageNavigation.
-bool ExtensionWebNavigationTabObserver::IsReferenceFragmentNavigation(
+bool WebNavigationTabObserver::IsReferenceFragmentNavigation(
     int64 frame_id,
     const GURL& url) {
   GURL existing_url = navigation_state_.GetUrl(frame_id);
   if (existing_url == url)
     return false;
 
   url_canon::Replacements<char> replacements;
   replacements.ClearRef();
   return existing_url.ReplaceComponents(replacements) ==
       url.ReplaceComponents(replacements);
@@ skipping 13 matching lines @@
   result_.reset(Value::CreateNullValue());
 
   TabContentsWrapper* wrapper;
   if (!ExtensionTabUtil::GetTabById(
         tab_id, profile(), include_incognito(), NULL, NULL, &wrapper, NULL) ||
       !wrapper) {
     return true;
   }
 
   WebContents* web_contents = wrapper->web_contents();
-  ExtensionWebNavigationTabObserver* observer =
-      ExtensionWebNavigationTabObserver::Get(web_contents);
+  WebNavigationTabObserver* observer =
+      WebNavigationTabObserver::Get(web_contents);
   DCHECK(observer);
 
   const FrameNavigationState& frame_navigation_state =
       observer->frame_navigation_state();
 
   if (frame_id == 0)
     frame_id = frame_navigation_state.GetMainFrameID();
   if (!frame_navigation_state.IsValidFrame(frame_id))
     return true;
 
@@ skipping 21 matching lines @@
   result_.reset(Value::CreateNullValue());
 
   TabContentsWrapper* wrapper;
   if (!ExtensionTabUtil::GetTabById(
         tab_id, profile(), include_incognito(), NULL, NULL, &wrapper, NULL) ||
       !wrapper) {
     return true;
   }
 
   WebContents* web_contents = wrapper->web_contents();
-  ExtensionWebNavigationTabObserver* observer =
-      ExtensionWebNavigationTabObserver::Get(web_contents);
+  WebNavigationTabObserver* observer =
+      WebNavigationTabObserver::Get(web_contents);
   DCHECK(observer);
 
   const FrameNavigationState& navigation_state =
       observer->frame_navigation_state();
 
   ListValue* resultList = new ListValue();
   for (FrameNavigationState::const_iterator frame = navigation_state.begin();
        frame != navigation_state.end(); ++frame) {
     GURL frame_url = navigation_state.GetUrl(*frame);
     if (!navigation_state.IsValidUrl(frame_url))
       continue;
     DictionaryValue* frameDict = new DictionaryValue();
     frameDict->SetString(keys::kUrlKey, frame_url.spec());
     frameDict->SetInteger(
         keys::kFrameIdKey,
         GetFrameId(navigation_state.IsMainFrame(*frame), *frame));
     frameDict->SetBoolean(
         keys::kErrorOccurredKey,
         navigation_state.GetErrorOccurredInFrame(*frame));
     resultList->Append(frameDict);
   }
   result_.reset(resultList);
   return true;
 }
+
+}  // namespace extensions