Links in platform apps should open in the system default browser.

chrome/browser/ui/extensions/shell_window.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.
 
 #include "chrome/browser/ui/extensions/shell_window.h"
 
+#include "base/command_line.h"
+#include "base/memory/singleton.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/shell_window_geometry_cache.h"
 #include "chrome/browser/extensions/shell_window_registry.h"
 #include "chrome/browser/file_select_helper.h"
 #include "chrome/browser/infobars/infobar_tab_helper.h"
 #include "chrome/browser/intents/web_intents_util.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
+#include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_id.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
+#include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/extensions/native_shell_window.h"
 #include "chrome/browser/ui/intents/web_intent_picker_controller.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/view_type_utils.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 27 matching lines @@
 void SuspendRenderViewHost(RenderViewHost* rvh) {
   DCHECK(rvh);
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
       base::Bind(&ResourceDispatcherHost::BlockRequestsForRoute,
           base::Unretained(ResourceDispatcherHost::Get()),
           rvh->GetProcess()->GetID(), rvh->GetRoutingID()));
 }
 
 }  // namespace
 
+// ExternalUrlController is a singleton class for link navigation.
+// It helps to open URL in system default browser.
+class ExternalUrlController : public content::WebContentsDelegate {
+ public:
+  static ExternalUrlController* GetInstance();
+
+ private:
+  ExternalUrlController() {}
+  friend struct DefaultSingletonTraits<ExternalUrlController>;
+
+  // content::WebContentsDelegate implementation.
+  virtual content::WebContents* OpenURLFromTab(
+      content::WebContents* source,
+      const content::OpenURLParams& params) OVERRIDE;
+
+  // For test usage.
+  content::WebContents* OpenInNewTab(
+      const content::OpenURLParams& params);
+
+  DISALLOW_COPY_AND_ASSIGN(ExternalUrlController);
+};
+
+// static
+ExternalUrlController* ExternalUrlController::GetInstance() {
+  return Singleton<ExternalUrlController>::get();
+}
+
+content::WebContents* ExternalUrlController::OpenURLFromTab(
+    content::WebContents* source,
+    const content::OpenURLParams& params) {
+  // Delete useless web content first to
+  // avoid a potential leak in a render process host.
+  delete source;
+
+  // This should only happen in PlatformAppBrowserTest.
+  CommandLine* command_line = CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch("OpenLinkTest")) {

[Mihai Parparita -not on Chrome, 2012/09/29 00:28:44]

Test behavior is normally not overridden via command line flags (the test run in
the same process, so there's no need to pass in flags).

The usual behavior is to have a static function that lets you override the
behavior, along the lines of:

http://code.google.com/searchframe#OAMlx_jo-ck/src/chrome/browser/extensions/...

In this case, you could have a ShellWindow::SetExternalUrlControllerForTesting
that lets you override the default delegate that you use. Then in your test, you
can pass in an implementation that opens a new tab (or not even that, it could
just store the URL, and then the test can check for it).

This also avoids having too much test-specific code in the implementation .cc
file.

+    return OpenInNewTab(params);
+  }
+
+#if defined(OS_MACOSX)
+  // This must run on the UI thread on OS X.
+  platform_util::OpenExternal(params.url);
+#else
+  // Otherwise put this work on the file thread. On Windows ShellExecute may
+  // block for a significant amount of time, and it shouldn't hurt on Linux.
+  BrowserThread::PostTask(
+      BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&platform_util::OpenExternal, params.url));
+#endif
+
+  return NULL;
+}
+
+content::WebContents* ExternalUrlController::OpenInNewTab(
+    const content::OpenURLParams& params) {
+  WindowOpenDisposition disposition = params.disposition;
+  content::OpenURLParams new_tab_params = params;
+  new_tab_params.disposition =
+      disposition == NEW_BACKGROUND_TAB ? disposition : NEW_FOREGROUND_TAB;
+  for (BrowserList::const_iterator i = BrowserList::begin();
+      i != BrowserList::end(); ++i) {
+    if ((*i)->is_type_tabbed()) {
+      Browser* browser = *i;
+      WebContents* new_tab = browser->OpenURL(new_tab_params);
+      browser->window()->Show();
+      return new_tab;
+    }
+  }
+  return NULL;
+}
+
 ShellWindow::CreateParams::CreateParams()
   : frame(ShellWindow::CreateParams::FRAME_CHROME),
     bounds(-1, -1, kDefaultWidth, kDefaultHeight),
     restore_position(true), restore_size(true) {
 }
 
 ShellWindow::CreateParams::~CreateParams() {
 }
 
 ShellWindow* ShellWindow::Create(Profile* profile,
@@ skipping 179 matching lines @@
 
 void ShellWindow::AddNewContents(WebContents* source,
                                  WebContents* new_contents,
                                  WindowOpenDisposition disposition,
                                  const gfx::Rect& initial_pos,
                                  bool user_gesture,
                                  bool* was_blocked) {
   DCHECK(source == web_contents_);
   DCHECK(Profile::FromBrowserContext(new_contents->GetBrowserContext()) ==
       profile_);
+
+#if defined(OS_WIN) || defined(OS_MACOSX) || defined(OS_LINUX)
+  new_contents->SetDelegate(ExternalUrlController::GetInstance());
+#else
   Browser* browser = browser::FindOrCreateTabbedBrowser(profile_);
   // Force all links to open in a new tab, even if they were trying to open a
   // new window.
   disposition =
       disposition == NEW_BACKGROUND_TAB ? disposition : NEW_FOREGROUND_TAB;
   chrome::AddWebContents(browser, NULL, new_contents, disposition, initial_pos,
                          user_gesture, was_blocked);
+#endif
 }
 
 void ShellWindow::HandleKeyboardEvent(
     WebContents* source,
     const content::NativeWebKeyboardEvent& event) {
   DCHECK_EQ(source, web_contents_);
   native_window_->HandleKeyboardEvent(event);
 }
 
 void ShellWindow::OnNativeClose() {
@@ skipping 164 matching lines @@
   if (window_key_.empty())
     return;
 
   extensions::ShellWindowGeometryCache* cache =
       extensions::ExtensionSystem::Get(profile())->
           shell_window_geometry_cache();
 
   gfx::Rect bounds = native_window_->GetBounds();
   cache->SaveGeometry(extension()->id(), window_key_, bounds);
 }