[DO NOT COMMIT] Remove chrome::NOTIFICATION_RETARGETING

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/api/web_navigation/web_navigation_api.h"
 
 #include "base/lazy_instance.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 32 matching lines @@
 namespace keys = web_navigation_api_constants;
 namespace web_navigation = api::web_navigation;
 
 namespace {
 
 typedef std::map<content::WebContents*, WebNavigationTabObserver*>
     TabObserverMap;
 static base::LazyInstance<TabObserverMap> g_tab_observer =
     LAZY_INSTANCE_INITIALIZER;
 
+typedef std::map<content::WebContents*,
+                 WebNavigationEventRouter::PendingWebContents>
+    PendingWebContentsMap;
+static base::LazyInstance<PendingWebContentsMap> g_pending_web_contents =
+    LAZY_INSTANCE_INITIALIZER;
+
 }  // namespace
 
 // WebNavigtionEventRouter -------------------------------------------
 
 WebNavigationEventRouter::PendingWebContents::PendingWebContents()
     : source_web_contents(NULL),
       source_frame_host(NULL),
       target_web_contents(NULL),
       target_url() {
 }
@@ skipping 54 matching lines @@
 
   helpers::DispatchOnTabReplaced(old_contents, profile_, new_contents);
 }
 
 void WebNavigationEventRouter::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_RETARGETING: {
+      LOG(ERROR) << "WNTO::Observe: retargeting";
       Profile* profile = content::Source<Profile>(source).ptr();
       if (profile->GetOriginalProfile() == profile_) {
         Retargeting(
             content::Details<const RetargetingDetails>(details).ptr());
       }
       break;
     }
 
     case chrome::NOTIFICATION_TAB_ADDED:
+      LOG(ERROR) << "WNTO::Observe: tab added";
       TabAdded(content::Details<content::WebContents>(details).ptr());
       break;
 
     case content::NOTIFICATION_WEB_CONTENTS_DESTROYED:
+      LOG(ERROR) << "WNTO::Observe: web contents destroyed";
       TabDestroyed(content::Source<content::WebContents>(source).ptr());
       break;
 
     default:
       NOTREACHED();
   }
 }
 
 void WebNavigationEventRouter::Retargeting(const RetargetingDetails* details) {
+  LOG(ERROR) << "WNER::Retargeting: "
+             << " url:" << details->target_url
+             << " source wc:" << details->source_web_contents
+             << " target wc:" << details->target_web_contents
+             << " not yet in ts:" << details->not_yet_in_tabstrip;
   if (details->source_render_frame_id == 0)
     return;
   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(GetViewType(details->source_web_contents) != VIEW_TYPE_TAB_CONTENTS);
     return;
   }
   const FrameNavigationState& frame_navigation_state =
       tab_observer->frame_navigation_state();
 
   content::RenderFrameHost* frame_host = content::RenderFrameHost::FromID(
       details->source_render_process_id, details->source_render_frame_id);
   if (!frame_navigation_state.CanSendEvents(frame_host))
     return;
 
   // If the WebContents isn't yet inserted into a tab strip, we need to delay
   // the extension event until the WebContents is fully initialized.
   if (details->not_yet_in_tabstrip) {
-    pending_web_contents_[details->target_web_contents] =
-        PendingWebContents(details->source_web_contents,
-                           frame_host,
-                           details->target_web_contents,
-                           details->target_url);
+    g_pending_web_contents.Get()[details->target_web_contents] =
+        PendingWebContents(details->source_web_contents, frame_host,
+                           details->target_web_contents, details->target_url);
   } else {
     helpers::DispatchOnCreatedNavigationTarget(
         details->source_web_contents,
         details->target_web_contents->GetBrowserContext(),
         frame_host,
         details->target_web_contents,
         details->target_url);
   }
 }
 
 void WebNavigationEventRouter::TabAdded(content::WebContents* tab) {
   std::map<content::WebContents*, PendingWebContents>::iterator iter =
-      pending_web_contents_.find(tab);
-  if (iter == pending_web_contents_.end())
+      g_pending_web_contents.Get().find(tab);
+  if (iter == g_pending_web_contents.Get().end())
     return;
 
   WebNavigationTabObserver* tab_observer =
       WebNavigationTabObserver::Get(iter->second.source_web_contents);
   if (!tab_observer) {
     NOTREACHED();
     return;
   }
   const FrameNavigationState& frame_navigation_state =
       tab_observer->frame_navigation_state();
 
   if (frame_navigation_state.CanSendEvents(iter->second.source_frame_host)) {
     helpers::DispatchOnCreatedNavigationTarget(
         iter->second.source_web_contents,
         iter->second.target_web_contents->GetBrowserContext(),
         iter->second.source_frame_host,
         iter->second.target_web_contents,
         iter->second.target_url);
   }
-  pending_web_contents_.erase(iter);
+  g_pending_web_contents.Get().erase(iter);
 }
 
 void WebNavigationEventRouter::TabDestroyed(content::WebContents* tab) {
-  pending_web_contents_.erase(tab);
+  g_pending_web_contents.Get().erase(tab);
   for (std::map<content::WebContents*, PendingWebContents>::iterator i =
-           pending_web_contents_.begin(); i != pending_web_contents_.end(); ) {
+           g_pending_web_contents.Get().begin();
+       i != g_pending_web_contents.Get().end();) {
     if (i->second.source_web_contents == tab)
-      pending_web_contents_.erase(i++);
+      g_pending_web_contents.Get().erase(i++);
     else
       ++i;
   }
 }
 
 // WebNavigationTabObserver ------------------------------------------
 
 WebNavigationTabObserver::WebNavigationTabObserver(
     content::WebContents* web_contents)
     : WebContentsObserver(web_contents) {
@@ skipping 34 matching lines @@
   if (old_host) {
     RenderFrameDeleted(old_host);
     navigation_state_.FrameHostDeleted(old_host);
   }
 
   navigation_state_.FrameHostCreated(new_host);
 }
 
 void WebNavigationTabObserver::DidStartNavigation(
     content::NavigationHandle* navigation_handle) {
+  LOG(ERROR) << "WNTP::DidStartNavigation: handle:" << navigation_handle;
   if (navigation_handle->IsSynchronousNavigation() ||
       !FrameNavigationState::IsValidUrl(navigation_handle->GetURL())) {
     return;
   }
 
   helpers::DispatchOnBeforeNavigate(navigation_handle);
 }
 
 void WebNavigationTabObserver::DidFinishNavigation(
     content::NavigationHandle* navigation_handle) {
+  LOG(ERROR) << "WNTP::DidFinishNavigation: handle:" << navigation_handle;
   if (navigation_handle->HasCommitted() && !navigation_handle->IsErrorPage()) {
     HandleCommit(navigation_handle);
     return;
   }
 
   HandleError(navigation_handle);
 }
 
 void WebNavigationTabObserver::DocumentLoadedInFrame(
     content::RenderFrameHost* render_frame_host) {
@@ skipping 70 matching lines @@
   navigation_state_.SetErrorOccurredInFrame(render_frame_host);
 }
 
 void WebNavigationTabObserver::DidOpenRequestedURL(
     content::WebContents* new_contents,
     content::RenderFrameHost* source_render_frame_host,
     const GURL& url,
     const content::Referrer& referrer,
     WindowOpenDisposition disposition,
     ui::PageTransition transition) {
+  LOG(ERROR) << "WNTO::DidOpenRequestedURL: "
+             << " new_contents:" << new_contents << " url:" << url
+             << " disposition:" << (int)disposition
+             << " source rfh:" << source_render_frame_host;
+
   if (!navigation_state_.CanSendEvents(source_render_frame_host))
     return;
 
   // We only send the onCreatedNavigationTarget if we end up creating a new
   // window.
   if (disposition != WindowOpenDisposition::SINGLETON_TAB &&
       disposition != WindowOpenDisposition::NEW_FOREGROUND_TAB &&
       disposition != WindowOpenDisposition::NEW_BACKGROUND_TAB &&
       disposition != WindowOpenDisposition::NEW_POPUP &&
       disposition != WindowOpenDisposition::NEW_WINDOW &&
       disposition != WindowOpenDisposition::OFF_THE_RECORD)
     return;
 
+  if (!ExtensionTabUtil::GetTabById(
+          ExtensionTabUtil::GetTabId(new_contents),
+          Profile::FromBrowserContext(new_contents->GetBrowserContext()), false,
+          NULL, NULL, NULL, NULL)) {
+    DCHECK_EQ(web_contents(), content::WebContents::FromRenderFrameHost(
+                                  source_render_frame_host));
+
+    g_pending_web_contents.Get()[new_contents] =
+        WebNavigationEventRouter::PendingWebContents(
+            web_contents(), source_render_frame_host, new_contents, url);
+    return;
+  }
+
   helpers::DispatchOnCreatedNavigationTarget(web_contents(),
                                              new_contents->GetBrowserContext(),
                                              source_render_frame_host,
                                              new_contents,
                                              url);
 }
 
 void WebNavigationTabObserver::WebContentsDestroyed() {
   g_tab_observer.Get().erase(web_contents());
   registrar_.RemoveAll();
@@ skipping 168 matching lines @@
   return g_factory.Pointer();
 }
 
 void WebNavigationAPI::OnListenerAdded(const EventListenerInfo& details) {
   web_navigation_event_router_.reset(new WebNavigationEventRouter(
       Profile::FromBrowserContext(browser_context_)));
   EventRouter::Get(browser_context_)->UnregisterObserver(this);
 }
 
 }  // namespace extensions