Extensions: Store disable reasons in Sync

chrome/browser/sync/test/integration/sync_extension_helper.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/sync/test/integration/sync_extension_helper.h"
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/extensions/pending_extension_info.h"
 #include "chrome/browser/extensions/pending_extension_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sync/test/integration/sync_datatype_helper.h"
 #include "chrome/browser/sync/test/integration/sync_test.h"
 #include "components/crx_file/id_util.h"
+#include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/install_flag.h"
 #include "extensions/browser/uninstall_reason.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/manifest_constants.h"
 #include "sync/api/string_ordinal.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using extensions::Extension;
+using extensions::ExtensionPrefs;
 using extensions::ExtensionRegistry;
 using extensions::Manifest;
 
 SyncExtensionHelper::ExtensionState::ExtensionState()
-    : enabled_state(ENABLED), incognito_enabled(false) {}
+    : enabled_state(ENABLED), disable_reasons(0), incognito_enabled(false) {}
 
 SyncExtensionHelper::ExtensionState::~ExtensionState() {}
 
 bool SyncExtensionHelper::ExtensionState::Equals(
     const SyncExtensionHelper::ExtensionState &other) const {
   return ((enabled_state == other.enabled_state) &&
+          (disable_reasons == other.disable_reasons) &&
           (incognito_enabled == other.incognito_enabled));
 }
 
 // static
 SyncExtensionHelper* SyncExtensionHelper::GetInstance() {
   SyncExtensionHelper* instance = Singleton<SyncExtensionHelper>::get();
   instance->SetupIfNecessary(sync_datatype_helper::test());
   return instance;
 }
 
@@ skipping 147 matching lines @@
   const std::string& profile_debug_name = profile->GetDebugName();
 
   ExtensionStateMap extension_state_map;
 
   scoped_ptr<const extensions::ExtensionSet> extensions(
       extensions::ExtensionRegistry::Get(profile)
           ->GenerateInstalledExtensionsSet());
 
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
-  for (extensions::ExtensionSet::const_iterator it = extensions->begin();
-       it != extensions->end(); ++it) {
-    const std::string& id = (*it)->id();
+  for (const scoped_refptr<const Extension>& extension : *extensions) {
+    const std::string& id = extension->id();
     extension_state_map[id].enabled_state =

[not at google - send to devlin, 2015/05/12 18:04:17]

Consider saving a reference to extension_state_map[id] so that you don't need to
write it every time.

[Marc Treib, 2015/05/19 12:12:03]

Done. (Should it be a pointer instead of a reference? I was under the impression
that non-const references aren't allowed, but now can't find a rule in the style
guide that would forbid them.)

[not at google - send to devlin, 2015/05/19 14:32:10]

I use non-const references for references into STL collections to avoid copying
/ convenient mutability, but that's about all. Some builder patterns use it too,
like DictionaryBuilder:
https://code.google.com/p/chromium/codesearch#chromium/src/extensions/common/...

Anything that leaves the immediate scope I use const reference or a pointer.
*This* is in the style guide:
https://google-styleguide.googlecode.com/svn/trunk/cppguide.html#Reference_Ar....

[Marc Treib, 2015/05/19 15:30:56]

Yup, I only found that as well.
Alright, thanks for the explanation! This use of non-const references should be
okay then :) (though I've seen reviewers suggest pointers in similar cases...)

         extension_service->IsExtensionEnabled(id) ?
         ExtensionState::ENABLED :
         ExtensionState::DISABLED;
+    extension_state_map[id].disable_reasons =
+        ExtensionPrefs::Get(profile)->GetDisableReasons(id);
     extension_state_map[id].incognito_enabled =
         extensions::util::IsIncognitoEnabled(id, profile);
 
-    DVLOG(2) << "Extension " << (*it)->id() << " in profile "
-             << profile_debug_name << " is "
-             << (extension_service->IsExtensionEnabled(id) ?
-                 "enabled" : "disabled");
+    DVLOG(2) << "Extension " << id << " in profile " << profile_debug_name
+             << " is " << (extension_service->IsExtensionEnabled(id) ?
+                           "enabled" : "disabled");
   }
 
   const extensions::PendingExtensionManager* pending_extension_manager =
       extension_service->pending_extension_manager();
 
   std::list<std::string> pending_crx_ids;
   pending_extension_manager->GetPendingIdsForUpdateCheck(&pending_crx_ids);
 
   std::list<std::string>::const_iterator id;
-  for (id = pending_crx_ids.begin(); id != pending_crx_ids.end(); ++id) {
-    extension_state_map[*id].enabled_state = ExtensionState::PENDING;
-    extension_state_map[*id].incognito_enabled =
-        extensions::util::IsIncognitoEnabled(*id, profile);
-    DVLOG(2) << "Extension " << *id << " in profile "
+  for (const std::string& id : pending_crx_ids) {
+    extension_state_map[id].enabled_state = ExtensionState::PENDING;
+    extension_state_map[id].disable_reasons =
+        ExtensionPrefs::Get(profile)->GetDisableReasons(id);
+    extension_state_map[id].incognito_enabled =
+        extensions::util::IsIncognitoEnabled(id, profile);
+    DVLOG(2) << "Extension " << id << " in profile "
              << profile_debug_name << " is pending";
   }
 
   return extension_state_map;
 }
 
 bool SyncExtensionHelper::ExtensionStatesMatch(
     Profile* profile1, Profile* profile2) {
   const ExtensionStateMap& state_map1 = GetExtensionStates(profile1);
   const ExtensionStateMap& state_map2 = GetExtensionStates(profile2);
@@ skipping 143 matching lines @@
     EXPECT_EQ(expected_id, extension->id());
     return NULL;
   }
   DVLOG(2) << "created extension with name = "
            << name << ", id = " << expected_id;
   (it->second)[name] = extension;
   id_to_name_[expected_id] = name;
   id_to_type_[expected_id] = type;
   return extension;
 }