Apps&Extensions for Supervised Users: send permission request on outdated re-enables

chrome/browser/extensions/extension_sync_service.cc

 // Copyright 2013 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/extensions/extension_sync_service.h"
 
 #include "base/basictypes.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/bookmark_app_helper.h"
 #include "chrome/browser/extensions/extension_service.h"
@@ skipping 13 matching lines @@
 #include "extensions/browser/extension_util.h"
 #include "extensions/browser/uninstall_reason.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/image_util.h"
 #include "extensions/common/permissions/permission_message_provider.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_error_factory.h"
 
+#if defined(ENABLE_SUPERVISED_USERS)
+#include "chrome/browser/supervised_user/supervised_user_service.h"
+#include "chrome/browser/supervised_user/supervised_user_service_factory.h"
+#endif
+
 using extensions::AppSorting;
 using extensions::Extension;
 using extensions::ExtensionPrefs;
 using extensions::ExtensionRegistry;
 using extensions::ExtensionSet;
 using extensions::ExtensionSyncData;
 using extensions::ExtensionSystem;
 using extensions::SyncBundle;
 
 namespace {
@@ skipping 89 matching lines @@
     bundle->PushSyncAddOrUpdate(extension.id(),
                                 CreateSyncData(extension).GetSyncData());
     DCHECK(!ExtensionPrefs::Get(profile_)->NeedsSync(extension.id()));
   } else {
     ExtensionPrefs::Get(profile_)->SetNeedsSync(extension.id(), true);
     if (extension_service()->is_ready() && !flare_.is_null())
       flare_.Run(type);  // Tell sync to start ASAP.
   }
 }
 
+bool ExtensionSyncService::HasPendingReenable(
+    const std::string& id,
+    const base::Version& version) const {
+  auto it = pending_updates_.find(id);
+  if (it == pending_updates_.end())
+    return false;
+  const PendingUpdate& pending = it->second;
+  return pending.version.Equals(version) &&
+         pending.grant_permissions_and_reenable;
+}
+
 syncer::SyncMergeResult ExtensionSyncService::MergeDataAndStartSyncing(
     syncer::ModelType type,
     const syncer::SyncDataList& initial_sync_data,
     scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
     scoped_ptr<syncer::SyncErrorFactory> sync_error_factory) {
   CHECK(sync_processor.get());
   LOG_IF(FATAL, type != syncer::EXTENSIONS && type != syncer::APPS)
       << "Got " << type << " ModelType";
 
   SyncBundle* bundle = GetSyncBundle(type);
@@ skipping 179 matching lines @@
         DCHECK(granted_permissions.get());
         bool is_privilege_increase =
             extensions::PermissionMessageProvider::Get()->IsPrivilegeIncrease(
                 *granted_permissions,
                 extension->permissions_data()->active_permissions(),
                 extension->GetType());
         if (!is_privilege_increase)
           extension_service()->EnableExtension(id);
         else if (extension_sync_data.supports_disable_reasons())
           reenable_after_update = true;
+
+#if defined(ENABLE_SUPERVISED_USERS)
+        if (is_privilege_increase && version_compare_result > 0 &&

[Marc Treib, 2015/10/16 12:40:36]

This was that bug - I was generating a permission request in exactly the wrong
case. It didn't show in the test since I was creating both and old and a new
approval...

+            extensions::util::IsExtensionSupervised(extension, profile_)) {
+          SupervisedUserServiceFactory::GetForProfile(profile_)
+              ->AddExtensionUpdateRequest(id, *extension->version());
+        }
+#endif
       }
     } else {
       // The extension is not installed yet. Set it to enabled; we'll check for
       // permission increase when it's actually installed.
       extension_service()->EnableExtension(id);
     }
   } else {
     int disable_reasons = extension_sync_data.disable_reasons();
     if (extension_sync_data.remote_install()) {
       if (!(disable_reasons & Extension::DISABLE_REMOTE_INSTALL)) {
@@ skipping 266 matching lines @@
     if (IsCorrectSyncType(*extension, type) &&
         extensions::util::ShouldSync(extension.get(), profile_) &&
         (include_everything ||
          ExtensionPrefs::Get(profile_)->NeedsSync(extension->id()))) {
       // We should never have pending data for an installed extension.
       DCHECK(!GetSyncBundle(type)->HasPendingExtensionData(extension->id()));
       sync_data_list->push_back(CreateSyncData(*extension));
     }
   }
 }