Adding new extension sync integration tests. Also modified the way that profile

chrome/test/live_sync/live_sync_extension_helper.cc

 // Copyright (c) 2011 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/test/live_sync/live_sync_extension_helper.h"
 
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_service.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/common/extensions/extension_constants.h"
 #include "chrome/test/live_sync/live_sync_test.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 LiveSyncExtensionHelper::LiveSyncExtensionHelper() {}
 
 LiveSyncExtensionHelper::~LiveSyncExtensionHelper() {}
 
+bool LiveSyncExtensionHelper::ExtensionState::operator==(
+    const LiveSyncExtensionHelper::ExtensionState &other) const {
+  return ((enabled_state == other.enabled_state) &&
+          (incognito_enabled == other.incognito_enabled));
+}
+
 // static
 std::string LiveSyncExtensionHelper::NameToId(const std::string& name) {
   std::string id;
   EXPECT_TRUE(Extension::GenerateId(name, &id));
   return id;
 }
 
 void LiveSyncExtensionHelper::Setup(LiveSyncTest* test) {
   for (int i = 0; i < test->num_clients(); ++i) {
     SetupProfile(test->GetProfile(i));
   }
   SetupProfile(test->verifier());
 }
 
 void LiveSyncExtensionHelper::InstallExtension(
     Profile* profile, const std::string& name, Extension::Type type) {
   scoped_refptr<Extension> extension = GetExtension(profile, name, type);
   ASSERT_TRUE(extension.get()) << "Could not get extension " << name
                                << " (profile = " << profile << ")";
   profile->GetExtensionService()->OnExtensionInstalled(extension);
 }
 
 void LiveSyncExtensionHelper::UninstallExtension(
     Profile* profile, const std::string& name) {
   ExtensionService::UninstallExtensionHelper(profile->GetExtensionService(),
                                              NameToId(name));
 }
 
+void LiveSyncExtensionHelper::EnableExtension(Profile* profile,
+                                              const std::string& name) {
+  profile->GetExtensionService()->EnableExtension(NameToId(name));
+}
+
+void LiveSyncExtensionHelper::DisableExtension(Profile* profile,
+                                               const std::string& name) {
+  profile->GetExtensionService()->DisableExtension(NameToId(name));
+}
+
+void LiveSyncExtensionHelper::IncognitoEnableExtension(
+    Profile* profile, const std::string& name) {
+  profile->GetExtensionService()->SetIsIncognitoEnabled(NameToId(name), true);
+}
+
+void LiveSyncExtensionHelper::IncognitoDisableExtension(
+    Profile* profile, const std::string& name) {
+  profile->GetExtensionService()->SetIsIncognitoEnabled(NameToId(name), false);
+}
+
 bool LiveSyncExtensionHelper::IsExtensionPendingInstallForSync(
     Profile* profile, const std::string& id) const {
   const PendingExtensionManager* pending_extension_manager =
       profile->GetExtensionService()->pending_extension_manager();
   PendingExtensionInfo info;
   if (!pending_extension_manager->GetById(id, &info)) {
     return false;
   }
   return info.is_from_sync();
 }
@@ skipping 32 matching lines @@
         Profile* profile) const {
   const std::string& profile_debug_name = profile->GetDebugName();
 
   ExtensionStateMap extension_state_map;
 
   ExtensionService* extension_service = profile->GetExtensionService();
 
   const ExtensionList* extensions = extension_service->extensions();
   for (ExtensionList::const_iterator it = extensions->begin();
        it != extensions->end(); ++it) {
-    extension_state_map[(*it)->id()] = ENABLED;
+    extension_state_map[(*it)->id()].enabled_state = ExtensionState::ENABLED;
+    if (extension_service->IsIncognitoEnabled((*it)->id())) {

[akalin, 2011/06/09 20:35:37]

lotta duplicated code.  Perhaps decomp into a separate function,
SetIncognitoState(ExtensionState*, const ExtensionService&)?

[braffert, 2011/06/09 23:09:35]

I'm not sure if this is a good idea as such a function would require a second
pass through all three extension lists (enabled, disabled, pending).  I've
cleaned up the code so that there is less repetition.  Also, the extra VLOG
statements shouldn't have made it into the last CL - they were added while
debugging.

+      extension_state_map[(*it)->id()].incognito_enabled = true;

[akalin, 2011/06/09 20:35:37]

simpler to do

extension_state_map[...].incognito_enabled =
extension_service->IsIncognitoEnabled(...);
VLOG(2) << "Incognito enabled: " << extension_state_map[...].incognito_enabled

[braffert, 2011/06/09 23:09:35]

Done.

+      VLOG(2) << "incognito enabled...";
+    } else {
+      extension_state_map[(*it)->id()].incognito_enabled = false;
+      VLOG(2) << "incognito disabled...";
+    }
     VLOG(2) << "Extension " << (*it)->id() << " in profile "
             << profile_debug_name << " is enabled";
   }
 
   const ExtensionList* disabled_extensions =
       extension_service->disabled_extensions();
   for (ExtensionList::const_iterator it = disabled_extensions->begin();
        it != disabled_extensions->end(); ++it) {
-    extension_state_map[(*it)->id()] = DISABLED;
+    extension_state_map[(*it)->id()].enabled_state = ExtensionState::DISABLED;
+    if (extension_service->IsIncognitoEnabled((*it)->id())) {
+      extension_state_map[(*it)->id()].incognito_enabled = true;
+      VLOG(2) << "incognito enabled...";
+    } else {
+      extension_state_map[(*it)->id()].incognito_enabled = false;
+      VLOG(2) << "incognito disabled...";
+    }
     VLOG(2) << "Extension " << (*it)->id() << " in profile "
             << profile_debug_name << " is disabled";
   }
 
   const PendingExtensionManager* pending_extension_manager =
       extension_service->pending_extension_manager();
   PendingExtensionManager::const_iterator it;
   for (it = pending_extension_manager->begin();
        it != pending_extension_manager->end(); ++it) {
-    extension_state_map[it->first] = PENDING;
+    extension_state_map[it->first].enabled_state = ExtensionState::PENDING;
+    if (extension_service->IsIncognitoEnabled(it->first)) {
+      extension_state_map[it->first].incognito_enabled = true;
+      VLOG(2) << "incognito enabled...";
+    } else {
+      extension_state_map[it->first].incognito_enabled = false;
+      VLOG(2) << "incognito disabled...";
+    }
     VLOG(2) << "Extension " << it->first << " in profile "
             << profile_debug_name << " is pending";
   }
 
   return extension_state_map;
 }
 
 void LiveSyncExtensionHelper::SetupProfile(Profile* profile) {
   profile->InitExtensions(true);
   profile_extensions_.insert(make_pair(profile, ExtensionNameMap()));
@@ skipping 99 matching lines @@
   if (extension->id() != expected_id) {
     EXPECT_EQ(expected_id, extension->id());
     return NULL;
   }
   VLOG(2) << "created extension with name = "
           << name << ", id = " << expected_id;
   (it->second)[name] = extension;
   id_to_name_[expected_id] = name;
   return extension;
 }