Create a copy of each app's shim bundle in the app's app_data_path.

chrome/browser/web_applications/web_app_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/web_applications/web_app_mac.h"
 
 #import <Carbon/Carbon.h>
 #import <Cocoa/Cocoa.h>
 
 #include "base/command_line.h"
@@ skipping 148 matching lines @@
   return false;
 }
 
 }  // namespace
 
 namespace web_app {
 
 const char kChromeAppDirName[] = "Chrome Apps.localized";
 
 WebAppShortcutCreator::WebAppShortcutCreator(
-    const base::FilePath& user_data_dir,
+    const base::FilePath& web_app_path,
     const ShellIntegration::ShortcutInfo& shortcut_info,
     const string16& chrome_bundle_id)
-    : user_data_dir_(user_data_dir),
+    : web_app_path_(web_app_path),
       info_(shortcut_info),
       chrome_bundle_id_(chrome_bundle_id) {
 }
 
 WebAppShortcutCreator::~WebAppShortcutCreator() {
 }
 
 base::FilePath WebAppShortcutCreator::GetShortcutPath() const {
   base::FilePath dst_path = GetDestinationPath();
   if (dst_path.empty())
     return dst_path;
 
   base::FilePath app_name = internals::GetSanitizedFileName(UTF8ToUTF16(
       info_.profile_path.BaseName().value() + " " + info_.extension_id));
   return dst_path.Append(app_name.ReplaceExtension("app"));
 }
 
 bool WebAppShortcutCreator::CreateShortcut() {
   base::FilePath app_path = GetShortcutPath();
   base::FilePath app_name = app_path.BaseName();
   base::FilePath dst_path = app_path.DirName();
   if (app_path.empty() || !file_util::DirectoryExists(dst_path.DirName())) {
     LOG(ERROR) << "Couldn't find an Applications directory to copy app to.";
     return false;
   }
+  if (!file_util::CreateDirectory(web_app_path_)) {
+    LOG(ERROR) << "Creating web_app_path " << web_app_path_.value()
+               << " failed.";
+    return false;
+  }
   if (!file_util::CreateDirectory(dst_path)) {
     LOG(ERROR) << "Creating directory " << dst_path.value() << " failed.";
     return false;
   }
 
   base::ScopedTempDir scoped_temp_dir;
   if (!scoped_temp_dir.CreateUniqueTempDir())
     return false;
   base::FilePath staging_path = scoped_temp_dir.path().Append(app_name);
 
   // Update the app's plist and icon in a temp directory. This works around
   // a Finder bug where the app's icon doesn't properly update.
   if (!file_util::CopyDirectory(GetAppLoaderPath(), staging_path, true)) {
     LOG(ERROR) << "Copying app to staging path: " << staging_path.value()
-               << " failed";
+               << " failed.";
     return false;
   }
 
   if (!UpdatePlist(staging_path))
     return false;
 
   if (!UpdateDisplayName(staging_path))
     return false;
 
   if (!UpdateIcon(staging_path))
     return false;
 
-  if (!file_util::CopyDirectory(staging_path, dst_path, true)) {
-    LOG(ERROR) << "Copying app to dst path: " << dst_path.value() << " failed";
+  // Put one copy in the app's web_app_path so we can still run it if the user

[benwells, 2013/06/13 00:13:31]

What happens if the shortcut is being created in response to the create
shortcuts dialog? The shim might already exist in the web app path.

[jackhou1, 2013/06/13 01:33:43]

It will replace the shim with the same files (though some contents of those
files change). E.g. the profile name could have changed in the mean time.

Though I realised in the update case, we don't want to create a new shortcut in
the apps folder if it has been deleted. I'll update the other CL.

[benwells, 2013/06/13 03:57:43]

On other platforms we have used the shortcut location struct as an argument to
all these functions to control where we put shortcuts. It feels like this would
be nicer if we did the same here. Then when a shortcut is added by the user we
just add it in the applications folder. When we are adding it automatically we
add it to both.

The more commonality between the platforms' code the better.

WDYT?

[jackhou1, 2013/06/14 03:31:27]

At the moment, there's no dialog to choose where to create shortcuts. So as far
as the user can tell, we're just making a shortcut in the Chrome Apps folder.

In terms of not creating it in the app_data_path, I think it would be better to
do that when app shims are enabled for good. At the moment, we don't know if
there is a copy in the app_data_path, or if that copy is up to date. So I'd
prefer that "Create shortcuts" recreates all shortcuts to a consistent state.

+  // deletes the one in the applications folder.
+  if (!file_util::CopyDirectory(staging_path, web_app_path_, true)) {
+    NOTREACHED();
     return false;
   }
+  base::mac::RemoveQuarantineAttribute(web_app_path_.Append(app_name));
+
+  if (!file_util::CopyDirectory(staging_path, dst_path, true))
+    return false;
 
   base::mac::RemoveQuarantineAttribute(app_path);
+
   RevealGeneratedBundleInFinder(app_path);
 
   return true;
 }
 
 base::FilePath WebAppShortcutCreator::GetAppLoaderPath() const {
   return base::mac::PathForFrameworkBundleResource(
       base::mac::NSToCFCast(@"app_mode_loader.app"));
 }
 
@@ skipping 34 matching lines @@
         [value substringWithRange:NSMakeRange(1, [value length] - 2)];
 
     NSString* substitution = [replacement_dict valueForKey:variable];
     if (substitution)
       [plist setObject:substitution forKey:key];
   }
 
   // 2. Fill in other values.
   [plist setObject:GetBundleIdentifier(plist)
             forKey:base::mac::CFToNSCast(kCFBundleIdentifierKey)];
-  [plist setObject:base::mac::FilePathToNSString(user_data_dir_)
+  [plist setObject:base::mac::FilePathToNSString(web_app_path_)
             forKey:app_mode::kCrAppModeUserDataDirKey];
   [plist setObject:base::mac::FilePathToNSString(info_.profile_path.BaseName())
             forKey:app_mode::kCrAppModeProfileDirKey];
   [plist setObject:base::SysUTF8ToNSString(info_.profile_name)
             forKey:app_mode::kCrAppModeProfileNameKey];
   [plist setObject:[NSNumber numberWithBool:YES]
             forKey:app_mode::kLSHasLocalizedDisplayNameKey];
 
   base::FilePath app_name = app_path.BaseName().RemoveExtension();
   [plist setObject:base::mac::FilePathToNSString(app_name)
@@ skipping 79 matching lines @@
     const base::FilePath& generated_bundle) const {
   [[NSWorkspace sharedWorkspace]
                     selectFile:base::mac::FilePathToNSString(generated_bundle)
       inFileViewerRootedAtPath:nil];
 }
 
 void LaunchShimOnFileThread(
       const ShellIntegration::ShortcutInfo& shortcut_info) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
   base::FilePath shim_path = web_app::GetAppInstallPath(shortcut_info);
-  if (shim_path.empty())
-    return;
+
+  if (shim_path.empty() || !file_util::PathExists(shim_path)) {
+    // The user may have deleted the copy in the Applications folder, use the
+    // one in the web app's web_app_path.
+    base::FilePath web_app_path = GetWebAppDataDirectory(
+        shortcut_info.profile_path, shortcut_info.extension_id, GURL());
+    shim_path = web_app_path.Append(shim_path.BaseName());
+  }
 
   CommandLine command_line(CommandLine::NO_PROGRAM);
   command_line.AppendSwitch(app_mode::kNoLaunchApp);
   base::mac::OpenApplicationWithPath(shim_path, command_line, NULL);
 }
 
 }  // namespace
 
 namespace web_app {
 
@@ skipping 59 matching lines @@
     const base::FilePath& web_app_path,
     const string16& old_app_title,
     const ShellIntegration::ShortcutInfo& shortcut_info) {
   // TODO(benwells): Implement this when shortcuts / weblings are enabled on
   // mac.
 }
 
 }  // namespace internals
 
 }  // namespace web_app