Added a private chromeAuthPrivate API.

chrome/common/extensions/extension.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/common/extensions/extension.h"
 
 #include <algorithm>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
@@ skipping 254 matching lines @@
 const int Extension::kSidebarIconMaxSize = 16;
 
 // Explicit permissions -- permission declaration required.
 const char Extension::kBackgroundPermission[] = "background";
 const char Extension::kBookmarkPermission[] = "bookmarks";
 const char Extension::kClipboardReadPermission[] = "clipboardRead";
 const char Extension::kClipboardWritePermission[] = "clipboardWrite";
 const char Extension::kContextMenusPermission[] = "contextMenus";
 const char Extension::kContentSettingsPermission[] = "contentSettings";
 const char Extension::kCookiePermission[] = "cookies";
+const char Extension::kChromeAuthPrivatePermission[] = "chromeAuthPrivate";
 const char Extension::kChromePrivatePermission[] = "chromePrivate";
 const char Extension::kChromeosInfoPrivatePermission[] = "chromeosInfoPrivate";
 const char Extension::kDebuggerPermission[] = "debugger";
 const char Extension::kExperimentalPermission[] = "experimental";
 const char Extension::kFileBrowserHandlerPermission[] = "fileBrowserHandler";
 const char Extension::kFileBrowserPrivatePermission[] = "fileBrowserPrivate";
 const char Extension::kGeolocationPermission[] = "geolocation";
 const char Extension::kHistoryPermission[] = "history";
 const char Extension::kIdlePermission[] = "idle";
 const char Extension::kManagementPermission[] = "management";
 const char Extension::kMediaPlayerPrivatePermission[] = "mediaPlayerPrivate";
 const char Extension::kNotificationPermission[] = "notifications";
 const char Extension::kProxyPermission[] = "proxy";
 const char Extension::kTabPermission[] = "tabs";
 const char Extension::kUnlimitedStoragePermission[] = "unlimitedStorage";
 const char Extension::kWebstorePrivatePermission[] = "webstorePrivate";
 const char Extension::kWebSocketProxyPrivatePermission[] =
     "webSocketProxyPrivate";
 
 // In general, all permissions should have an install message.
 // See ExtensionsTest.PermissionMessages for an explanation of each
 // exception.
 const Extension::Permission Extension::kPermissions[] = {
   { kBackgroundPermission,            PermissionMessage::ID_NONE },
   { kBookmarkPermission,              PermissionMessage::ID_BOOKMARKS },
+  { kChromeAuthPrivatePermission,     PermissionMessage::ID_NONE },
   { kChromePrivatePermission,         PermissionMessage::ID_NONE },
   { kChromeosInfoPrivatePermission,   PermissionMessage::ID_NONE },
   { kClipboardReadPermission,         PermissionMessage::ID_CLIPBOARD },
   { kClipboardWritePermission,        PermissionMessage::ID_NONE },
   { kContentSettingsPermission,       PermissionMessage::ID_NONE },
   { kContextMenusPermission,          PermissionMessage::ID_NONE },
   { kCookiePermission,                PermissionMessage::ID_NONE },
   { kDebuggerPermission,              PermissionMessage::ID_DEBUGGER },
   { kExperimentalPermission,          PermissionMessage::ID_NONE },
   { kFileBrowserHandlerPermission,    PermissionMessage::ID_NONE },
   { kFileBrowserPrivatePermission,    PermissionMessage::ID_NONE },
   { kGeolocationPermission,           PermissionMessage::ID_GEOLOCATION },
   { kHistoryPermission,               PermissionMessage::ID_BROWSING_HISTORY },
   { kIdlePermission,                  PermissionMessage::ID_NONE },
   { kManagementPermission,            PermissionMessage::ID_MANAGEMENT },
   { kMediaPlayerPrivatePermission,    PermissionMessage::ID_NONE },
   { kNotificationPermission,          PermissionMessage::ID_NONE },
   { kProxyPermission,                 PermissionMessage::ID_NONE },
   { kTabPermission,                   PermissionMessage::ID_TABS },
   { kUnlimitedStoragePermission,      PermissionMessage::ID_NONE },
   { kWebSocketProxyPrivatePermission, PermissionMessage::ID_NONE },
   { kWebstorePrivatePermission,       PermissionMessage::ID_NONE },
 };
 const size_t Extension::kNumPermissions = arraysize(Extension::kPermissions);
 
 const char* const Extension::kHostedAppPermissionNames[] = {
   Extension::kBackgroundPermission,
+  Extension::kChromeAuthPrivatePermission,
   Extension::kChromePrivatePermission,
   Extension::kClipboardReadPermission,
   Extension::kClipboardWritePermission,
   Extension::kExperimentalPermission,
   Extension::kGeolocationPermission,
   Extension::kNotificationPermission,
   Extension::kUnlimitedStoragePermission,
   Extension::kWebstorePrivatePermission,
 };
 const size_t Extension::kNumHostedAppPermissions =
     arraysize(Extension::kHostedAppPermissionNames);
 
 const char* const Extension::kComponentPrivatePermissionNames[] = {
+    Extension::kChromeAuthPrivatePermission,
     Extension::kFileBrowserPrivatePermission,
     Extension::kWebstorePrivatePermission,
     Extension::kMediaPlayerPrivatePermission,
     Extension::kChromeosInfoPrivatePermission,
 };
 const size_t Extension::kNumComponentPrivatePermissions =
     arraysize(Extension::kComponentPrivatePermissionNames);
 
 // We purposefully don't put this into kPermissionNames.
 const char Extension::kOldUnlimitedStoragePermission[] = "unlimited_storage";
@@ skipping 180 matching lines @@
   std::set<std::string>::const_iterator i;
   for (i = api_permissions().begin(); i != api_permissions().end(); ++i) {
     PermissionMessage::MessageId message_id = GetPermissionMessageId(*i);
     DCHECK_GT(PermissionMessage::ID_NONE, PermissionMessage::ID_UNKNOWN);
     if (message_id > PermissionMessage::ID_NONE)
       messages.insert(PermissionMessage::CreateFromMessageId(message_id));
   }
   return messages;
 }
 
+void Extension::OverrideLaunchUrl(const GURL& override_url) {
+  GURL new_url(override_url);
+  if (!new_url.is_valid()) {
+    LOG(WARNING) << "Invalid override url given for " << name();
+  } else {
+    if (new_url.has_port()) {
+      LOG(WARNING) << "Override URL passed for " << name()
+                   << " should not contain a port.  Removing it.";
+
+      GURL::Replacements remove_port;
+      remove_port.ClearPort();
+      new_url = new_url.ReplaceComponents(remove_port);
+    }
+
+    launch_web_url_ = new_url.spec();
+
+    URLPattern pattern(kValidWebExtentSchemes);
+    pattern.Parse(new_url.spec(), URLPattern::PARSE_STRICT);
+    pattern.SetPath(pattern.path() + '*');
+    extent_.AddPattern(pattern);
+  }
+}
+
 // static
 std::vector<std::string> Extension::GetDistinctHostsForDisplay(
     const URLPatternList& list) {
   return GetDistinctHosts(list, true);
 }
 
 // static
 bool Extension::IsElevatedHostList(
     const URLPatternList& old_list, const URLPatternList& new_list) {
   // TODO(jstritar): This is overly conservative with respect to subdomains.
@@ skipping 820 matching lines @@
   // In order for the --apps-gallery-url switch to work with the gallery
   // process isolation, we must insert any provided value into the component
   // app's launch url and web extent.
   if (id() == extension_misc::kWebStoreAppId) {
     std::string gallery_url_str = CommandLine::ForCurrentProcess()->
         GetSwitchValueASCII(switches::kAppsGalleryURL);
 
     // Empty string means option was not used.
     if (!gallery_url_str.empty()) {
       GURL gallery_url(gallery_url_str);
-      if (!gallery_url.is_valid()) {
-        LOG(WARNING) << "Invalid url given in switch "
-                     << switches::kAppsGalleryURL;
-      } else {
-        if (gallery_url.has_port()) {
-          LOG(WARNING) << "URLs passed to switch " << switches::kAppsGalleryURL
-                       << " should not contain a port.  Removing it.";
-
-          GURL::Replacements remove_port;
-          remove_port.ClearPort();
-          gallery_url = gallery_url.ReplaceComponents(remove_port);
-        }
-
-        launch_web_url_ = gallery_url.spec();
-
-        URLPattern pattern(kValidWebExtentSchemes);
-        pattern.Parse(gallery_url.spec(), URLPattern::PARSE_STRICT);
-        pattern.SetPath(pattern.path() + '*');
-        extent_.AddPattern(pattern);
-      }
+      OverrideLaunchUrl(gallery_url);
+    }
+  } else if (id() == extension_misc::kCloudPrintAppId) {
+    // In order for the --cloud-print-service switch to work, we must update
+    // the launch URL and web extent.
+    // TODO(sanjeevr): Ideally we want to use CloudPrintURL here but that is
+    // currently under chrome/browser.
+    const CommandLine& command_line = *CommandLine::ForCurrentProcess();
+    GURL cloud_print_service_url = GURL(command_line.GetSwitchValueASCII(
+        switches::kCloudPrintServiceURL));
+    if (!cloud_print_service_url.is_empty()) {
+      std::string path(
+          cloud_print_service_url.path() + "/enable_chrome_connector");
+      GURL::Replacements replacements;
+      replacements.SetPathStr(path);
+      GURL cloud_print_enable_connector_url =
+          cloud_print_service_url.ReplaceComponents(replacements);
+      OverrideLaunchUrl(cloud_print_enable_connector_url);
     }
   }
-
   return true;
 }
 
 bool Extension::LoadLaunchContainer(const DictionaryValue* manifest,
                                     std::string* error) {
   Value* temp = NULL;
   if (!manifest->Get(keys::kLaunchContainer, &temp))
     return true;
 
   std::string launch_container_string;
@@ skipping 1748 matching lines @@
 
 UninstalledExtensionInfo::~UninstalledExtensionInfo() {}
 
 
 UnloadedExtensionInfo::UnloadedExtensionInfo(
     const Extension* extension,
     Reason reason)
   : reason(reason),
     already_disabled(false),
     extension(extension) {}