Append parameters to webstore URL to indicate launch source.

chrome/browser/ui/browser.cc

 // Copyright (c) 2011 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/browser.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <shellapi.h>
 #endif  // OS_WIN
@@ skipping 232 matching lines @@
     return true;
 
   // If the |virtual_url()| isn't a chrome:// URL, check if it's actually
   // view-source: of a chrome:// URL.
   if (entry->virtual_url().SchemeIs(chrome::kViewSourceScheme))
     return entry->url().SchemeIs(chrome::kChromeUIScheme);
 
   return false;
 }
 
+// Get the launch URL for a given extension, with optional override/fallback.
+// |override_url|, if non-empty, will be preferred over the extension's
+// launch url.
+GURL UrlForExtension(const Extension* extension, const GURL& override_url) {
+  if (!extension)
+    return override_url;
+
+  GURL url;
+  if (!override_url.is_empty()) {
+    DCHECK(extension->web_extent().MatchesURL(override_url));
+    url = override_url;
+  } else {
+    url = extension->GetFullLaunchURL();
+  }
+
+  // For extensions lacking launch urls, determine a reasonable fallback.
+  if (!url.is_valid()) {
+    url = extension->options_url();
+    if (!url.is_valid()) {
+      url = GURL(std::string(chrome::kChromeUISettingsURL) +
+                 chrome::kExtensionsSubPage);
+    }
+  }
+
+  return url;
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // Browser, CreateParams:
 
 Browser::CreateParams::CreateParams(Type type, Profile* profile)
     : type(type),
       profile(profile) {
 }
 
@@ skipping 311 matching lines @@
       profile->GetOffTheRecordProfile());
   browser->AddSelectedTabWithURL(url, content::PAGE_TRANSITION_LINK);
   browser->window()->Show();
 }
 
 // static
 TabContents* Browser::OpenApplication(
     Profile* profile,
     const Extension* extension,
     extension_misc::LaunchContainer container,
+    const GURL& override_url,
     WindowOpenDisposition disposition) {
 #if defined(USE_AURA)
   // On aura we're experimenting with making all apps open in windows.
   container = extension_misc::LAUNCH_WINDOW;
 #endif
   TabContents* tab = NULL;
   ExtensionPrefs* prefs = profile->GetExtensionService()->extension_prefs();
   prefs->SetActiveBit(extension->id(), true);
 
   UMA_HISTOGRAM_ENUMERATION("Extensions.AppLaunchContainer", container, 100);
 
   switch (container) {
     case extension_misc::LAUNCH_WINDOW:
     case extension_misc::LAUNCH_PANEL:
       tab = Browser::OpenApplicationWindow(profile, extension, container,
-                                           GURL(), NULL);
+                                           override_url, NULL);
       break;
     case extension_misc::LAUNCH_TAB: {
-      tab = Browser::OpenApplicationTab(profile, extension, disposition);
+      tab = Browser::OpenApplicationTab(profile, extension, override_url,
+                                        disposition);
       break;
     }
     default:
       NOTREACHED();
       break;
   }
   return tab;
 }
 
 // static
 TabContents* Browser::OpenApplicationWindow(
     Profile* profile,
     const Extension* extension,
     extension_misc::LaunchContainer container,
     const GURL& url_input,
     Browser** app_browser) {
-  GURL url;
-  if (!url_input.is_empty()) {
-    if (extension)
-      DCHECK(extension->web_extent().MatchesURL(url_input));
-    url = url_input;
-  } else {
-    DCHECK(extension);  // Empty url and no extension.  Nothing to open.
-    url = extension->GetFullLaunchURL();
-  }
+  DCHECK(!url_input.is_empty() || extension);
+  GURL url = UrlForExtension(extension, url_input);
 
   std::string app_name;
-  if (extension)
-    app_name =
-        web_app::GenerateApplicationNameFromExtensionId(extension->id());
-  else
-    app_name = web_app::GenerateApplicationNameFromURL(url);
+  app_name = extension ?
+      web_app::GenerateApplicationNameFromExtensionId(extension->id()) :
+      web_app::GenerateApplicationNameFromURL(url);
 
   Type type = extension && (container == extension_misc::LAUNCH_PANEL) ?
       TYPE_PANEL : TYPE_POPUP;
 
   gfx::Rect window_bounds;
   if (extension) {
     window_bounds.set_width(extension->launch_width());
     window_bounds.set_height(extension->launch_height());
   }
 
@@ skipping 38 matching lines @@
     // web_app::UpdateShortcutForTabContents when it sees UPDATE_SHORTCUT as
     // pending web app action.
     app_browser->pending_web_app_action_ = UPDATE_SHORTCUT;
   }
   return tab;
 }
 
 // static
 TabContents* Browser::OpenApplicationTab(Profile* profile,
                                          const Extension* extension,
+                                         const GURL& override_url,
                                          WindowOpenDisposition disposition) {
   Browser* browser = BrowserList::FindTabbedBrowser(profile, false);
   TabContents* contents = NULL;
   if (!browser) {
     // No browser for this profile, need to open a new one.
     browser = Browser::Create(profile);
     browser->window()->Show();
     // There's no current tab in this browser window, so add a new one.
     disposition = NEW_FOREGROUND_TAB;
   }
@@ skipping 13 matching lines @@
     UMA_HISTOGRAM_ENUMERATION(
         base::FieldTrial::MakeName("Extensions.AppTabLaunchType",
                                    kDefaultAppsTrial_Name),
         launch_type, 100);
   }
 
   int add_type = TabStripModel::ADD_ACTIVE;
   if (launch_type == ExtensionPrefs::LAUNCH_PINNED)
     add_type |= TabStripModel::ADD_PINNED;
 
-  // For extensions lacking launch urls, determine a reasonable fallback.
-  GURL extension_url = extension->GetFullLaunchURL();
-  if (!extension_url.is_valid()) {
-    extension_url = extension->options_url();
-    if (!extension_url.is_valid())
-      extension_url = GURL(std::string(chrome::kChromeUISettingsURL) +
-                           chrome::kExtensionsSubPage);
-  }
-
+  GURL extension_url = UrlForExtension(extension, override_url);
   // TODO(erikkay): START_PAGE doesn't seem like the right transition in all
   // cases.
   browser::NavigateParams params(browser, extension_url,
                                  content::PAGE_TRANSITION_START_PAGE);
   params.tabstrip_add_types = add_type;
   params.disposition = disposition;
 
   if (disposition == CURRENT_TAB) {
     TabContents* existing_tab = browser->GetSelectedTabContents();
     TabStripModel* model = browser->tabstrip_model();
     int tab_index = model->GetWrapperIndex(existing_tab);
 
-    existing_tab->OpenURL(extension->GetFullLaunchURL(), existing_tab->GetURL(),
+    existing_tab->OpenURL(extension_url, existing_tab->GetURL(),
                           disposition, content::PAGE_TRANSITION_LINK);
     if (params.tabstrip_add_types & TabStripModel::ADD_PINNED) {
       model->SetTabPinned(tab_index, true);
       tab_index = model->GetWrapperIndex(existing_tab);
     }
     if (params.tabstrip_add_types & TabStripModel::ADD_ACTIVE)
       model->ActivateTabAt(tab_index, true);
 
     contents = existing_tab;
   } else {
     browser::Navigate(&params);
     contents = params.target_contents->tab_contents();
   }
 
   // TODO(skerner):  If we are already in full screen mode, and the user
   // set the app to open as a regular or pinned tab, what should happen?
   // Today we open the tab, but stay in full screen mode.  Should we leave
   // full screen mode in this case?
   if (launch_type == ExtensionPrefs::LAUNCH_FULLSCREEN &&
-      !browser->window()->IsFullscreen())
+      !browser->window()->IsFullscreen()) {
     browser->ToggleFullscreenMode(false);
+  }
 
   return contents;
 }
 
 // static
 void Browser::OpenBookmarkManagerWindow(Profile* profile) {
   Browser* browser = Browser::Create(profile);
   browser->OpenBookmarkManager();
   browser->window()->Show();
 }
@@ skipping 4728 matching lines @@
 }
 
 void Browser::UpdateFullscreenExitBubbleContent() {
   GURL url;
   if (fullscreened_tab_)
     url = fullscreened_tab_->tab_contents()->GetURL();
 
   window_->UpdateFullscreenExitBubbleContent(
       url, GetFullscreenExitBubbleType());
 }