PS - Remove Clipboard Read permission from extensions in Public Sessions (except for whitelisted on…

chrome/browser/extensions/permissions_updater.cc

 // 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.
 
 #include "chrome/browser/extensions/permissions_updater.h"
 
 #include <utility>
 
 #include "base/memory/ref_counted.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/permissions/permissions_api_helpers.h"
+#include "chrome/browser/extensions/permissions_updater_delegate_chromeos.h"
 #include "chrome/browser/extensions/scripting_permissions_modifier.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/permissions.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/notification_types.h"
@@ skipping 40 matching lines @@
       PermissionSet::CreateIntersection(*total_permissions,
                                         *active_permissions);
 
   // Make sure the active permissions contain the default permissions.
   adjusted_active =
       PermissionSet::CreateUnion(required_permissions, *adjusted_active);
 
   return adjusted_active;
 }
 
+PermissionsUpdater::Delegate* g_delegate = nullptr;
+
 }  // namespace
 
 PermissionsUpdater::PermissionsUpdater(content::BrowserContext* browser_context)
     : browser_context_(browser_context), init_flag_(INIT_FLAG_NONE) {
+#if defined(OS_CHROMEOS)
+  if (!g_delegate)

[Ivan Šandrk, 2017/04/04 15:41:56]

I'm not sure if the SetPlatformDelegate function is needed at all. And I'm also
not sure if doing it like this is ok.

[Devlin, 2017/04/05 14:35:20]

I think what would be better would be instead moving this call to SetDelegate to
chromeos session code.  I don't know that code well, but I'm assuming there's
some point at which we know that we're in a public session.  From there, we set
the delegate, since that's the only case we need.  Then, we don't need any
#ifdefs in this file! :)

[Ivan Šandrk, 2017/04/07 14:39:40]

Right, done.

+    SetPlatformDelegate(new PermissionsUpdaterDelegateChromeOS());
+#endif
 }
 
 PermissionsUpdater::PermissionsUpdater(content::BrowserContext* browser_context,
                                        InitFlag init_flag)
     : browser_context_(browser_context), init_flag_(init_flag) {
 }
 
 PermissionsUpdater::~PermissionsUpdater() {}
 
+// static
+void PermissionsUpdater::SetPlatformDelegate(Delegate* delegate) {
+  g_delegate = delegate;
+}
+
 void PermissionsUpdater::AddPermissions(const Extension* extension,
                                         const PermissionSet& permissions) {
   const PermissionSet& active =
       extension->permissions_data()->active_permissions();
   std::unique_ptr<const PermissionSet> total =
       PermissionSet::CreateUnion(active, permissions);
   std::unique_ptr<const PermissionSet> added =
       PermissionSet::CreateDifference(*total, active);
 
   std::unique_ptr<const PermissionSet> new_withheld =
@@ skipping 97 matching lines @@
 
   std::unique_ptr<const PermissionSet> granted_permissions;
   std::unique_ptr<const PermissionSet> withheld_permissions;
   ScriptingPermissionsModifier(browser_context_, make_scoped_refptr(extension))
       .WithholdPermissions(*bounded_active, &granted_permissions,
                            &withheld_permissions,
                            (init_flag_ & INIT_FLAG_TRANSIENT) != 0);
 
   SetPermissions(extension, std::move(granted_permissions),
                  std::move(withheld_permissions));
+
+  if (g_delegate)
+    g_delegate->InitializePermissions(this, extension);
 }
 
 void PermissionsUpdater::SetPermissions(
     const Extension* extension,
     std::unique_ptr<const PermissionSet> active,
     std::unique_ptr<const PermissionSet> withheld) {
   DCHECK(active);
   const PermissionSet& active_weak = *active;
   if (withheld) {
     extension->permissions_data()->SetPermissions(std::move(active),
@@ skipping 24 matching lines @@
   std::unique_ptr<Event> event(
       new Event(histogram_value, event_name, std::move(value)));
   event->restrict_to_browser_context = browser_context_;
   event_router->DispatchEventToExtension(extension_id, std::move(event));
 }
 
 void PermissionsUpdater::NotifyPermissionsUpdated(
     EventType event_type,
     const Extension* extension,
     const PermissionSet& changed) {
-  DCHECK((init_flag_ & INIT_FLAG_TRANSIENT) == 0);
+  DCHECK_EQ(init_flag_ & INIT_FLAG_TRANSIENT, 0);

[Ivan Šandrk, 2017/04/04 15:41:57]

Fixed linter error.

[Devlin, 2017/04/05 14:35:20]

Thanks!  But prefer DCHECK_EQ(expected, actual), so
DCHECK_EQ(0, init_flag & INIT_FLAG_TRANSIENT);

[Ivan Šandrk, 2017/04/07 14:39:40]

Done.

   if (changed.IsEmpty())
     return;
 
   UpdatedExtensionPermissionsInfo::Reason reason;
   events::HistogramValue histogram_value;
   const char* event_name = NULL;
 
   if (event_type == REMOVED) {
     reason = UpdatedExtensionPermissionsInfo::REMOVED;
     histogram_value = events::PERMISSIONS_ON_REMOVED;
@@ skipping 29 matching lines @@
             Profile::FromBrowserContext(host->GetBrowserContext()))) {
       host->Send(new ExtensionMsg_UpdatePermissions(params));
     }
   }
 
   // Trigger the onAdded and onRemoved events in the extension.
   DispatchEvent(extension->id(), histogram_value, event_name, changed);
 }
 
 }  // namespace extensions