Rename "managed (mode|user)" to "supervised user" (part 1)

chrome/browser/sync/sessions/sessions_sync_manager_unittest.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/sync/sessions/sessions_sync_manager.h"
 
 #include "base/strings/string_util.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/sessions/session_id.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
@@ skipping 338 matching lines @@
   ASSERT_EQ(1U,
             manager()->session_tracker_.num_synced_tabs(std::string("tag")));
 }
 
 namespace {
 
 class SyncedTabDelegateFake : public SyncedTabDelegate {
  public:
   SyncedTabDelegateFake() : current_entry_index_(0),
                             pending_entry_index_(-1),
-                            is_managed_(false),
+                            is_supervised_(false),
                             sync_id_(-1),
                             blocked_navigations_(NULL) {}
   virtual ~SyncedTabDelegateFake() {}
 
   virtual int GetCurrentEntryIndex() const OVERRIDE {
     return current_entry_index_;
   }
   void set_current_entry_index(int i) {
     current_entry_index_ = i;
   }
@@ skipping 30 matching lines @@
   virtual Profile* profile() const OVERRIDE { return NULL; }
   virtual std::string GetExtensionAppId() const OVERRIDE {
     return std::string();
   }
   virtual content::NavigationEntry* GetPendingEntry() const OVERRIDE {
    return NULL;
   }
   virtual content::NavigationEntry* GetActiveEntry() const OVERRIDE {
    return NULL;
   }
-  virtual bool ProfileIsManaged() const OVERRIDE {
-   return is_managed_;
+  virtual bool ProfileIsSupervised() const OVERRIDE {
+   return is_supervised_;
   }
-  void set_is_managed(bool is_managed) { is_managed_ = is_managed; }
+  void set_is_supervised(bool is_supervised) { is_supervised_ = is_supervised; }
   virtual const std::vector<const content::NavigationEntry*>*
       GetBlockedNavigations() const OVERRIDE {
     return blocked_navigations_;
   }
   void set_blocked_navigations(
       std::vector<const content::NavigationEntry*>* navs) {
     blocked_navigations_ = navs;
   }
   virtual bool IsPinned() const OVERRIDE {
    return false;
@@ skipping 16 matching lines @@
   void reset() {
     current_entry_index_ = 0;
     pending_entry_index_ = -1;
     sync_id_ = -1;
     entries_.clear();
   }
 
  private:
    int current_entry_index_;
    int pending_entry_index_;
-   bool is_managed_;
+   bool is_supervised_;
    int sync_id_;
    std::vector<const content::NavigationEntry*>* blocked_navigations_;
    ScopedVector<content::NavigationEntry> entries_;
 };
 
 }  // namespace
 
 // Test that we exclude tabs with only chrome:// and file:// schemed navigations
 // from ShouldSyncTab(..).
 TEST_F(SessionsSyncManagerTest, ValidTabs) {
@@ skipping 112 matching lines @@
   EXPECT_EQ(202, session_tab.navigations[2].http_status_code());
   EXPECT_EQ(SerializedNavigationEntry::STATE_INVALID,
             session_tab.navigations[0].blocked_state());
   EXPECT_EQ(SerializedNavigationEntry::STATE_INVALID,
             session_tab.navigations[1].blocked_state());
   EXPECT_EQ(SerializedNavigationEntry::STATE_INVALID,
             session_tab.navigations[2].blocked_state());
   EXPECT_TRUE(session_tab.session_storage_persistent_id.empty());
 }
 
-// Tests that for managed users blocked navigations are recorded and marked as
-// such, while regular navigations are marked as allowed.
+// Tests that for supervised users blocked navigations are recorded and marked
+// as such, while regular navigations are marked as allowed.
 TEST_F(SessionsSyncManagerTest, BlockedNavigations) {
   SyncedTabDelegateFake tab;
   content::NavigationEntry* entry1(content::NavigationEntry::Create());
   entry1->SetVirtualURL(GURL("http://www.google.com"));
   entry1->SetTimestamp(kTime1);
   tab.AppendEntry(entry1);
 
   content::NavigationEntry* entry2 = content::NavigationEntry::Create();
   entry2->SetVirtualURL(GURL("http://blocked.com/foo"));
   entry2->SetTimestamp(kTime2);
   content::NavigationEntry* entry3 = content::NavigationEntry::Create();
   entry3->SetVirtualURL(GURL("http://evil.com"));
   entry3->SetTimestamp(kTime3);
   ScopedVector<const content::NavigationEntry> blocked_navigations;
   blocked_navigations.push_back(entry2);
   blocked_navigations.push_back(entry3);
 
-  tab.set_is_managed(true);
+  tab.set_is_supervised(true);
   tab.set_blocked_navigations(&blocked_navigations.get());
 
   SessionTab session_tab;
   session_tab.window_id.set_id(1);
   session_tab.tab_id.set_id(1);
   session_tab.tab_visual_index = 1;
   session_tab.current_navigation_index = 1;
   session_tab.pinned = true;
   session_tab.extension_app_id = "app id";
   session_tab.user_agent_override = "override";
@@ skipping 1200 matching lines @@
   ASSERT_FALSE(observer.notified_of_refresh());
   InitWithNoSyncData();
   AddTab(browser(), GURL("http://foo1"));
   EXPECT_FALSE(observer.notified_of_refresh());
   NavigateAndCommitActiveTab(GURL("chrome://newtab/#open_tabs"));
   EXPECT_TRUE(observer.notified_of_refresh());
 }
 #endif  // defined(OS_ANDROID) || defined(OS_IOS)
 
 }  // namespace browser_sync