app_list: Drive app integration.

chrome/browser/apps/drive/drive_app_converter.cc

 // Copyright 2014 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/app_list/drive/drive_app_converter.h"
+#include "chrome/browser/apps/drive/drive_app_converter.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/install_tracker.h"
 #include "chrome/browser/image_decoder.h"
@@ skipping 92 matching lines @@
       app_(NULL),
       finished_callback_(finished_callback) {
   DCHECK(profile_);
 }
 
 DriveAppConverter::~DriveAppConverter() {
   PostInstallCleanUp();
 }
 
 void DriveAppConverter::Start() {
-  if (app_info_.app_name.empty() ||
-      !app_info_.create_url.is_valid()) {
+  DCHECK(!IsStarted());
+
+  if (app_info_.app_name.empty() || !app_info_.create_url.is_valid()) {
     finished_callback_.Run(this, false);
     return;
   }
 
   web_app_.title = base::UTF8ToUTF16(app_info_.app_name);
   web_app_.app_url = app_info_.create_url;
 
   const std::set<int> allowed_sizes(extension_misc::kExtensionIconSizes,
                                     extension_misc::kExtensionIconSizes +
                                         extension_misc::kNumExtensionIconSizes);
   std::set<int> pending_sizes;
   for (size_t i = 0; i < app_info_.app_icons.size(); ++i) {
     const int icon_size = app_info_.app_icons[i].first;
     if (allowed_sizes.find(icon_size) == allowed_sizes.end() ||
         pending_sizes.find(icon_size) != pending_sizes.end()) {
       continue;
     }
 
     pending_sizes.insert(icon_size);
     const GURL& icon_url = app_info_.app_icons[i].second;
     IconFetcher* fetcher = new IconFetcher(this, icon_url, icon_size);
     fetchers_.push_back(fetcher);  // Pass ownership to |fetchers|.
     fetcher->Start();
   }
 
   if (fetchers_.empty())
     StartInstall();
 }
 
+bool DriveAppConverter::IsStarted() const {
+  return !fetchers_.empty() || crx_installer_;
+}
+
 void DriveAppConverter::OnIconFetchComplete(const IconFetcher* fetcher) {
   const SkBitmap& icon = fetcher->icon();
   if (!icon.empty() && icon.width() != 0) {
     WebApplicationInfo::IconInfo icon_info;
     icon_info.url = fetcher->icon_url();
     icon_info.data = icon;
     icon_info.width = icon.width();
     icon_info.height = icon.height();
     web_app_.icons.push_back(icon_info);
   }
 
   fetchers_.erase(std::find(fetchers_.begin(), fetchers_.end(), fetcher));
 
   if (fetchers_.empty())
     StartInstall();
 }
 
 void DriveAppConverter::StartInstall() {
   DCHECK(!crx_installer_);
   crx_installer_ = extensions::CrxInstaller::CreateSilent(
       extensions::ExtensionSystem::Get(profile_)->extension_service());
+
+  // Sets WAS_INSTALLED_BY_DEFAULT to make the converted url app not syncable.
+  // Drive apps go with the user's account and url apps will be created when
+  // needed. Syncing those apps could hit an edge case where the synced url
+  // apps become orphans when the user has corresponding chrome apps.
+  crx_installer_->set_creation_flags(
+      extensions::Extension::FROM_BOOKMARK |
+      extensions::Extension::WAS_INSTALLED_BY_DEFAULT);

[stevenjb, 2014/06/05 20:15:16]

WAS_INSTALLED_BY_DEFAULT might trigger other behaviors, maybe we should add an
explicit IS_SYNCABLE flag?

[xiyuan, 2014/06/05 20:36:14]

The converted app is sort of a default (in a sense that it comes as part of the
user's account). I checked where WAS_INSTALLED_BY_DEFAULT is used (not many of
places) and seems to be safe to use.

But I'll leave this to the judgement of extensions OWNERs (benwells@, yoz@,
kalman@) and suggestions of what to use.

[Yoyo Zhou, 2014/06/05 20:45:33]

This isn't really what we mean by default apps; those come with the chrome
installation, rather than with a drive login. One of these would be better:

- if we could determine from the extension that it was a drive app, and
therefore not to sync it (see several existing cases in GetSyncType in
sync_helper.cc)
- if there was a new creation flag like SYNC_NOT_ALLOWED

[not at google - send to devlin, 2014/06/05 20:47:47]

I agree with Steven, even if this works at the moment it's absolutely not
"installed by default" and it's things like that have made sync bugs creep in in
the past.

Attaching this stuff to "creation flags" isn't really right anyway. Things like
it being a bookmark is a property of the environment not a property of the
extension itself, if that makes sense (basically: it should be stored in Prefs
not on the Extension object, if it needs to be).

If you don't want to sync it, how about a set_do_not_sync(..) function on the
CrxInstaller.

[xiyuan, 2014/06/05 21:17:06]

Okay.

- Add a ExtensionPrefs backed boolean property do_not_sync() to Extension;
- The property is initiated in CrxInstaller when creating the URL app;
- GetSyncType checks this property and returns SYNC_TYPE_NONE to disable sync
for this item. 

How does this sound?

[Yoyo Zhou, 2014/06/05 21:18:20]

Minor detail: you can check this in IsSyncable instead of GetSyncType. But
sounds fine to me.

+
   extensions::InstallTracker::Get(profile_)->AddObserver(this);
   crx_installer_->InstallWebApp(web_app_);
 }
 
 void DriveAppConverter::PostInstallCleanUp() {
   if (!crx_installer_)
     return;
 
   extensions::InstallTracker::Get(profile_)->RemoveObserver(this);
   crx_installer_ = NULL;
 }
 
 void DriveAppConverter::OnFinishCrxInstall(const std::string& extension_id,
                                            bool success) {
   if (!crx_installer_->extension() ||
       crx_installer_->extension()->id() != extension_id) {
     return;
   }
 
   app_ = crx_installer_->extension();
+  PostInstallCleanUp();
+
   finished_callback_.Run(this, success);
-
-  PostInstallCleanUp();
+  // |finished_callback_| could delete this.
 }