mac: Opening a URL should replace the NTP.

chrome/browser/app_controller_mac.mm

 // 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.
 
 #import "chrome/browser/app_controller_mac.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 195 matching lines @@
 }
 
 }  // anonymous namespace
 
 @interface AppController (Private)
 - (void)initMenuState;
 - (void)initProfileMenu;
 - (void)updateConfirmToQuitPrefMenuItem:(NSMenuItem*)item;
 - (void)updateDisplayMessageCenterPrefMenuItem:(NSMenuItem*)item;
 - (void)registerServicesMenuTypesTo:(NSApplication*)app;
-- (void)openUrls:(const std::vector<GURL>&)urls;
 - (void)getUrl:(NSAppleEventDescriptor*)event
      withReply:(NSAppleEventDescriptor*)reply;
 - (void)windowLayeringDidChange:(NSNotification*)inNotification;
 - (void)activeSpaceDidChange:(NSNotification*)inNotification;
 - (void)checkForAnyKeyWindows;
 - (BOOL)userWillWaitForInProgressDownloads:(int)downloadCount;
 - (BOOL)shouldQuitWithInProgressDownloads;
 - (void)executeApplication:(id)sender;
 - (void)profileWasRemoved:(const base::FilePath&)profilePath;
+
+// Opens a tab for each GURL in |urls|.
+- (void)openUrls:(const std::vector<GURL>&)urls;
+
+// This class cannot open urls until startup has finished. The urls that cannot
+// be opened are cached in |startupUrls_|. This method must be called exactly
+// once after startup has completed. It opens the urls in |startupUrls_|, and
+// clears |startupUrls_|.
+- (void)openStartupUrls;
+
+// Opens a tab for each GURL in |urls|. If there exactly 1 tab open before this

[Avi (use Gerrit), 2014/10/29 14:38:59]

"If there is exactly one tab"...

[erikchen, 2014/10/29 17:18:02]

Done.

+// method is called, and that tab is the NTP, then this method closes the NTP
+// after all the |urls| have been opened.
+- (void)openUrlsReplacingNTP:(const std::vector<GURL>&)urls;
 @end
 
 class AppControllerProfileObserver : public ProfileInfoCacheObserver {
  public:
   AppControllerProfileObserver(
       ProfileManager* profile_manager, AppController* app_controller)
       : profile_manager_(profile_manager),
         app_controller_(app_controller) {
     DCHECK(profile_manager_);
     DCHECK(app_controller_);
@@ skipping 417 matching lines @@
   if (!plist) {
     const float fiveHoursInSeconds = 5.0 * 60.0 * 60.0;
     NSNumber* value = [NSNumber numberWithFloat:fiveHoursInSeconds];
     CFPreferencesSetAppValue(checkInterval, value, app);
     CFPreferencesAppSynchronize(app);
   }
 #endif
 }
 
 - (void)openStartupUrls {
+  DCHECK(startupComplete_);
+  [self openUrlsReplacingNTP:startupUrls_];
+  startupUrls_.clear();
+}
+
+- (void)openUrlsReplacingNTP:(const std::vector<GURL>&)urls {
+  if (urls.empty())
+    return;
+
   // On Mac, the URLs are passed in via Cocoa, not command line. The Chrome
   // NSApplication is created in MainMessageLoop, and then the shortcut urls
   // are passed in via Apple events. At this point, the first browser is
   // already loaded in PreMainMessageLoop. If we initialize NSApplication
   // before PreMainMessageLoop to capture shortcut URL events, it may cause
   // more problems because it relies on things created in PreMainMessageLoop
   // and may break existing message loop design.
-  if (startupUrls_.empty())
+
+  // If the browser hasn't started yet, just queue up the URLs.
+  if (!startupComplete_) {
+    startupUrls_.insert(startupUrls_.end(), urls.begin(), urls.end());
     return;
+  }
 
   // If there's only 1 tab and the tab is NTP, close this NTP tab and open all
   // startup urls in new tabs, because the omnibox will stay focused if we
   // load url in NTP tab.
   Browser* browser = chrome::GetLastActiveBrowser();
   int startupIndex = TabStripModel::kNoTab;
   content::WebContents* startupContent = NULL;
 
   if (browser && browser->tab_strip_model()->count() == 1) {
     startupIndex = browser->tab_strip_model()->active_index();
     startupContent = browser->tab_strip_model()->GetActiveWebContents();
   }
 
-  if (startupUrls_.size()) {
-    [self openUrls:startupUrls_];
-    startupUrls_.clear();
-  }
+  [self openUrls:urls];
 
   if (startupIndex != TabStripModel::kNoTab &&
       startupContent->GetVisibleURL() == GURL(chrome::kChromeUINewTabURL)) {
     browser->tab_strip_model()->CloseWebContentsAt(startupIndex,
         TabStripModel::CLOSE_NONE);
   }
 }
 
 // This is called after profiles have been loaded and preferences registered.
 // It is safe to access the default profile here.
@@ skipping 609 matching lines @@
   if (profile->IsGuestSession())
     return profile->GetOffTheRecordProfile();
 
   return profile;
 }
 
 // Various methods to open URLs that we get in a native fashion. We use
 // StartupBrowserCreator here because on the other platforms, URLs to open come
 // through the ProcessSingleton, and it calls StartupBrowserCreator. It's best
 // to bottleneck the openings through that for uniform handling.
-
 - (void)openUrls:(const std::vector<GURL>&)urls {
-  // If the browser hasn't started yet, just queue up the URLs.
   if (!startupComplete_) {
     startupUrls_.insert(startupUrls_.end(), urls.begin(), urls.end());
     return;
   }
 
   Browser* browser = chrome::GetLastActiveBrowser();
   // if no browser window exists then create one with no tabs to be filled in
   if (!browser) {
     browser = new Browser(Browser::CreateParams(
         [self lastProfile], chrome::HOST_DESKTOP_TYPE_NATIVE));
     browser->window()->Show();
   }
 
   CommandLine dummy(CommandLine::NO_PROGRAM);
   chrome::startup::IsFirstRun first_run = first_run::IsChromeFirstRun() ?
       chrome::startup::IS_FIRST_RUN : chrome::startup::IS_NOT_FIRST_RUN;
   StartupBrowserCreatorImpl launch(base::FilePath(), dummy, first_run);
   launch.OpenURLsInBrowser(browser, false, urls, browser->host_desktop_type());
 }
 
 - (void)getUrl:(NSAppleEventDescriptor*)event
      withReply:(NSAppleEventDescriptor*)reply {
   NSString* urlStr = [[event paramDescriptorForKeyword:keyDirectObject]
                       stringValue];
 
   GURL gurl(base::SysNSStringToUTF8(urlStr));
   std::vector<GURL> gurlVector;
   gurlVector.push_back(gurl);
 
-  [self openUrls:gurlVector];
+  [self openUrlsReplacingNTP:gurlVector];
 }
 
 - (void)application:(NSApplication*)sender
           openFiles:(NSArray*)filenames {
   std::vector<GURL> gurlVector;
   for (NSString* file in filenames) {
     GURL gurl =
         net::FilePathToFileURL(base::FilePath([file fileSystemRepresentation]));
     gurlVector.push_back(gurl);
   }
   if (!gurlVector.empty())
-    [self openUrls:gurlVector];
+    [self openUrlsReplacingNTP:gurlVector];
   else
     NOTREACHED() << "Nothing to open!";
 
   [sender replyToOpenOrPrint:NSApplicationDelegateReplySuccess];
 }
 
 // Show the preferences window, or bring it to the front if it's already
 // visible.
 - (IBAction)showPreferences:(id)sender {
   if (Browser* browser = ActivateBrowser([self lastProfile])) {
@@ skipping 179 matching lines @@
   }
 
   NSURL* url = userActivity.webPageURL;
   if (!url)
     return NO;
 
   GURL gurl(base::SysNSStringToUTF8([url absoluteString]));
   std::vector<GURL> gurlVector;
   gurlVector.push_back(gurl);
 
-  [self openUrls:gurlVector];
+  [self openUrlsReplacingNTP:gurlVector];
   return YES;
 }
 
 - (void)application:(NSApplication*)application
     didFailToContinueUserActivityWithType:(NSString*)userActivityType
                                     error:(NSError*)error {
 }
 
 @end  // @implementation AppController
 
 //---------------------------------------------------------------------------
 
 namespace app_controller_mac {
 
 bool IsOpeningNewWindow() {
   return g_is_opening_new_window;
 }
 
 }  // namespace app_controller_mac