Reverting 9388.

chrome/browser/external_tab_container.cc

 // Copyright (c) 2006-2008 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/external_tab_container.h"
 
 #include "base/logging.h"
 #include "base/win_util.h"
 #include "chrome/browser/automation/automation_provider.h"
 #include "chrome/browser/profile.h"
@@ skipping 56 matching lines @@
   }
   tab_contents_->SetupController(profile);
   tab_contents_->set_delegate(this);
 
   WebContents* web_conents = tab_contents_->AsWebContents();
   if (web_conents)
     web_conents->render_view_host()->AllowExternalHostBindings();
 
   // Create a TabContentsContainerView to handle focus cycling using Tab and
   // Shift-Tab.
+  // TODO(sanjeevr): We need to create a dummy FocusTraversable object to
+  // represent the frame of the external host. This will allow Tab and
+  // Shift-Tab to cycle into the external frame.
   tab_contents_container_ = new TabContentsContainerView();
   root_view_.AddChildView(tab_contents_container_);
-  // Note that SetTabContents must be called after AddChildView is called
   tab_contents_container_->SetTabContents(tab_contents_);
-  // Add a dummy view to catch when the user tabs out of the tab
-  // Create a dummy FocusTraversable object to represent the frame of the
-  // external host. This will allow Tab and Shift-Tab to cycle into the
-  // external frame.  When the tab_contents_container_ loses focus,
-  // the focus will be moved to this class (See OnSetFocus in this file).
-  // An alternative to using views::View and catching when the focus manager
-  // shifts the focus to the dummy view could be to implement our own view
-  // and handle AboutToRequestFocusFromTabTraversal.
-  views::View* dummy = new views::View();
-  dummy->SetFocusable(true);
-  DCHECK(dummy->IsFocusable());
-  root_view_.AddChildView(dummy);
 
   NavigationController* controller = tab_contents_->controller();
   DCHECK(controller);
   registrar_.Add(this, NotificationType::NAV_ENTRY_COMMITTED,
                  Source<NavigationController>(controller));
   NotificationService::current()->Notify(
       NotificationType::EXTERNAL_TAB_CREATED,
       Source<NavigationController>(controller),
       NotificationService::NoDetails());
 
   // Now apply the parenting and style
   if (parent)
     SetParent(parent);
 
   // We need WS_POPUP to be on the window during initialization, but
   // once initialized and parent-ed, we apply the requested style which
   // may or may not include the popup bit.
   ModifyStyle(WS_POPUP, style, 0);
 
   ::ShowWindow(tab_contents_->GetContainerHWND(), SW_SHOW);
   return true;
 }
 
 void ExternalTabContainer::OnDestroy() {
-  views::FocusManager* focus_manager =
+  views::FocusManager * focus_manager =
       views::FocusManager::GetFocusManager(GetHWND());
   if (focus_manager) {
     focus_manager->RemoveKeystrokeListener(this);
   }
   root_view_.RemoveAllChildViews(true);
   if (tab_contents_) {
     NavigationController* controller = tab_contents_->controller();
     DCHECK(controller);
 
     NotificationService::current()->Notify(
@@ skipping 15 matching lines @@
   if (tab_contents_) {
     RECT client_rect = {0};
     GetClientRect(&client_rect);
     ::SetWindowPos(tab_contents_->GetContainerHWND(), NULL, client_rect.left,
                    client_rect.top, client_rect.right - client_rect.left,
                    client_rect.bottom - client_rect.top, SWP_NOZORDER);
   }
   return 0;
 }
 
-LRESULT ExternalTabContainer::OnSetFocus(UINT msg, WPARAM wp, LPARAM lp,
-                                         BOOL& handled) {
-  if (automation_) {
-    views::FocusManager* focus_manager =
-        views::FocusManager::GetFocusManager(GetHWND());
-    DCHECK(focus_manager);
-    if (focus_manager) {
-      focus_manager->ClearFocus();
-      automation_->Send(new AutomationMsg_TabbedOut(win_util::IsShiftPressed(),
-                                                    false));
-    }
-  }
-
-  return 0;
-}
+// TODO(sanjeevr): The implementation of the TabContentsDelegate interface
+// needs to be fully fleshed out based on the requirements of the
+// "Chrome tab in external browser" feature.
 
 void ExternalTabContainer::OpenURLFromTab(TabContents* source,
                            const GURL& url,
                            const GURL& referrer,
                            WindowOpenDisposition disposition,
                            PageTransition::Type transition) {
   switch (disposition) {
     case CURRENT_TAB:
     case NEW_FOREGROUND_TAB:
     case NEW_BACKGROUND_TAB:
     case NEW_WINDOW:
       if (automation_) {
         automation_->Send(new AutomationMsg_OpenURL(0, url, disposition));
       }
       break;
     default:
       break;
    }
 }
 
 void ExternalTabContainer::NavigationStateChanged(const TabContents* source,
-                                                  unsigned changed_flags) {
+                                    unsigned changed_flags) {
   if (automation_) {
     automation_->Send(
-        new AutomationMsg_NavigationStateChanged(0, changed_flags));
+        new AutomationMsg_NavigationStateChanged(0,changed_flags));
   }
 }
 
 void ExternalTabContainer::ReplaceContents(TabContents* source, TabContents* new_contents) {
 }
 
 void ExternalTabContainer::AddNewContents(TabContents* source,
                             TabContents* new_contents,
                             WindowOpenDisposition disposition,
                             const gfx::Rect& initial_pos,
                             bool user_gesture) {
 }
 
 void ExternalTabContainer::ActivateContents(TabContents* contents) {
 }
 
 void ExternalTabContainer::LoadingStateChanged(TabContents* source) {
 }
 
 void ExternalTabContainer::CloseContents(TabContents* source) {
 }
 
-void ExternalTabContainer::MoveContents(TabContents* source,
-                                        const gfx::Rect& pos) {
+void ExternalTabContainer::MoveContents(TabContents* source, const gfx::Rect& pos) {
 }
 
 bool ExternalTabContainer::IsPopup(TabContents* source) {
   return false;
 }
 
-void ExternalTabContainer::URLStarredChanged(TabContents* source,
-                                             bool starred) {
+void ExternalTabContainer::URLStarredChanged(TabContents* source, bool starred) {
 }
 
 void ExternalTabContainer::UpdateTargetURL(TabContents* source,
                                            const GURL& url) {
   if (automation_) {
     std::wstring url_string = CA2W(url.spec().c_str());
     automation_->Send(
         new AutomationMsg_UpdateTargetUrl(0, url_string));
   }
 }
 
 void ExternalTabContainer::ContentsZoomChange(bool zoom_in) {
 }
 
 void ExternalTabContainer::ToolbarSizeChanged(TabContents* source,
-                                              bool finished) {
+                                            bool finished) {
 }
 
 void ExternalTabContainer::ForwardMessageToExternalHost(
     const std::string& receiver, const std::string& message) {
   if(automation_) {
     automation_->Send(
         new AutomationMsg_ForwardMessageToExternalHost(0, receiver, message));
   }
 }
 
@@ skipping 47 matching lines @@
 
 bool ExternalTabContainer::IsVisible() {
   return !!::IsWindowVisible(*this);
 }
 
 bool ExternalTabContainer::IsActive() {
   return win_util::IsWindowActive(*this);
 }
 
 bool ExternalTabContainer::ProcessKeyDown(HWND window, UINT message,
-                                          WPARAM wparam, LPARAM lparam) {
+                                            WPARAM wparam, LPARAM lparam) {
   if (!automation_) {
     return false;
   }
   if ((wparam == VK_TAB) && !win_util::IsCtrlPressed()) {
     // Tabs are handled separately (except if this is Ctrl-Tab or
     // Ctrl-Shift-Tab)
     return false;
   }
   int flags = HIWORD(lparam);
   if ((flags & KF_EXTENDED) || (flags & KF_ALTDOWN) ||
@@ skipping 22 matching lines @@
 
 void ExternalTabContainer::ProcessUnhandledAccelerator(const MSG& msg) {
   // We just received an accelerator key that we had sent to external host
   // back. Since the external host was not interested in handling this, we
   // need to dispatch this message as if we had just peeked this out. (we
   // also need to call TranslateMessage to generate a WM_CHAR if needed).
   TranslateMessage(&msg);
   DispatchMessage(&msg);
 }
 
-void ExternalTabContainer::SetInitialFocus(bool reverse) {
-  DCHECK(tab_contents_);
-  if (tab_contents_) {
-    tab_contents_->SetInitialFocus(reverse);
-  }
-}
-
 // static
 bool ExternalTabContainer::IsExternalTabContainer(HWND window) {
   std::wstring class_name = win_util::GetClassName(window);
   return _wcsicmp(class_name.c_str(), chrome::kExternalTabWindowClass) == 0;
 }
 
 // static
 ExternalTabContainer* ExternalTabContainer::GetContainerForTab(
     HWND tab_window) {
   HWND parent_window = ::GetParent(tab_window);
   if (!::IsWindow(parent_window)) {
     return NULL;
   }
   if (!IsExternalTabContainer(parent_window)) {
     return NULL;
   }
   ExternalTabContainer* container = reinterpret_cast<ExternalTabContainer*>(
       GetProp(parent_window, kWindowObjectKey));
   return container;
 }