Show origin for hosted apps that navigate away from their start origin.

chrome/browser/ui/extensions/hosted_app_browser_controller.cc

 // Copyright 2015 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/bookmark_app_browser_controller.h"
+#include "chrome/browser/ui/extensions/hosted_app_browser_controller.h"
 
 #include "base/command_line.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ssl/connection_security_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/browser/ui/location_bar/location_bar.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/extension.h"
+#include "net/base/net_util.h"
 #include "url/gurl.h"
 
 namespace extensions {
 
 namespace {
 
 bool IsSameOriginOrMoreSecure(const GURL& app_url, const GURL& page_url) {
+  const std::string www("www.");
   return (app_url.scheme() == page_url.scheme() ||
           page_url.scheme() == url::kHttpsScheme) &&
-         app_url.host() == page_url.host() &&
+         (app_url.host() == page_url.host() ||
+          www + app_url.host() == page_url.host()) &&

[felt, 2015/06/04 19:21:34]

why single out www as the one allowable subdomain? if you want to support
subdomains, should it be all subdomains?

[benwells, 2015/06/04 23:54:42]

It shoudn't be all subdomains as benfredwells.github.io is different to
adrifelt.github.io.

I did www. as it is so common to redirect from a bare host name to www.hostname,
and the first hosted app I tested on did this :/

We could not bother with this and 'break' those hosted apps that do it (where
break == end up showing the location bar).

[felt, 2015/06/04 23:58:37]

ok, special casing www sounds reasonable to me. (although i'm puzzled about how
someone could end up bookmarking https://hostname when it always immediately
redirects to https://www.hostname)

          app_url.port() == page_url.port();
 }
 
 bool IsWebAppFrameEnabled() {
   return base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableWebAppFrame);
 }
 
 }  // namespace
 
 // static
-bool BookmarkAppBrowserController::IsForBookmarkApp(Browser* browser) {
+bool HostedAppBrowserController::IsForHostedApp(Browser* browser) {
   const std::string extension_id =
       web_app::GetExtensionIdFromApplicationName(browser->app_name());
   const Extension* extension =
       ExtensionRegistry::Get(browser->profile())->GetExtensionById(
           extension_id, ExtensionRegistry::EVERYTHING);
-  return extension && extension->from_bookmark();
+  return extension && extension->is_hosted_app();
 }
 
-BookmarkAppBrowserController::BookmarkAppBrowserController(Browser* browser)
+HostedAppBrowserController::HostedAppBrowserController(Browser* browser)
     : browser_(browser),
       extension_id_(
           web_app::GetExtensionIdFromApplicationName(browser->app_name())),
-      should_use_web_app_frame_(browser->host_desktop_type() ==
-                                    chrome::HOST_DESKTOP_TYPE_ASH &&
-                                IsWebAppFrameEnabled()) {
+      should_use_web_app_frame_(false) {
+  const Extension* extension =
+      ExtensionRegistry::Get(browser->profile())->GetExtensionById(
+          extension_id_, ExtensionRegistry::EVERYTHING);
+  should_use_web_app_frame_ =
+      extension && extension->from_bookmark() &&

[felt, 2015/06/04 19:21:33]

should this be a DCHECK(extension)? can extension ever be a nullptr here?

[benwells, 2015/06/05 01:20:44]

Done.

+      browser->host_desktop_type() == chrome::HOST_DESKTOP_TYPE_ASH &&
+      IsWebAppFrameEnabled();
 }
 
-BookmarkAppBrowserController::~BookmarkAppBrowserController() {
+HostedAppBrowserController::~HostedAppBrowserController() {
 }
 
-bool BookmarkAppBrowserController::SupportsLocationBar() {
+bool HostedAppBrowserController::SupportsLocationBar() const {
   return !should_use_web_app_frame();
 }
 
-bool BookmarkAppBrowserController::ShouldShowLocationBar() {
+bool HostedAppBrowserController::ShouldShowLocationBar() const {
   const Extension* extension =
       ExtensionRegistry::Get(browser_->profile())->GetExtensionById(
           extension_id_, ExtensionRegistry::EVERYTHING);
 
   const content::WebContents* web_contents =
       browser_->tab_strip_model()->GetActiveWebContents();
 
   // Default to not showing the location bar if either |extension| or
   // |web_contents| are null. |extension| is null for the dev tools.
   if (!extension || !web_contents)
     return false;
 
-  if (!extension->from_bookmark())
+  if (!extension->is_hosted_app())
     return false;
 
   // Don't show a location bar until a navigation has occurred.
   if (web_contents->GetLastCommittedURL().is_empty())
     return false;
 
   ConnectionSecurityHelper::SecurityLevel security_level =
       ConnectionSecurityHelper::GetSecurityLevelForWebContents(web_contents);
   if (security_level == ConnectionSecurityHelper::SECURITY_ERROR)
     return true;
 
   GURL launch_url = AppLaunchInfo::GetLaunchWebURL(extension);
   return !(IsSameOriginOrMoreSecure(launch_url,
                                     web_contents->GetVisibleURL()) &&
            IsSameOriginOrMoreSecure(launch_url,
                                     web_contents->GetLastCommittedURL()));
 }
 
-void BookmarkAppBrowserController::UpdateLocationBarVisibility(bool animate) {
+void HostedAppBrowserController::UpdateLocationBarVisibility(
+    bool animate) const {
   if (!SupportsLocationBar())
     return;
 
   browser_->window()->GetLocationBar()->UpdateLocationBarVisibility(
       ShouldShowLocationBar(), animate);
 }
 
 }  // namespace extensions