[TabManager] Move TabManager into chrome/browser/resource_coordinator.

chrome/browser/resource_coordinator/tab_manager_delegate_chromeos_unittest.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/memory/tab_manager_delegate_chromeos.h"
+#include "chrome/browser/resource_coordinator/tab_manager_delegate_chromeos.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/process/process_handle.h"
 #include "chromeos/dbus/fake_debug_daemon_client.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-namespace memory {
+namespace resource_coordinator {
 
 class TabManagerDelegateTest : public testing::Test {
  public:
   TabManagerDelegateTest() {}
   ~TabManagerDelegateTest() override {}
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
 };
 
@@ skipping 22 matching lines @@
 
   tab3.tab_contents_id = 300;
   tab3.is_pinned = true;
   tab3.is_media = true;
 
   tab4.tab_contents_id = 400;
   tab4.is_media = true;
 
   tab5.tab_contents_id = 500;
   tab5.is_app = true;
-  TabStatsList tab_list = {
-    tab1, tab2, tab3, tab4, tab5
-  };
+  TabStatsList tab_list = {tab1, tab2, tab3, tab4, tab5};
 
   std::vector<TabManagerDelegate::Candidate> candidates;
 
-  candidates = TabManagerDelegate::GetSortedCandidates(
-          tab_list, arc_processes);
+  candidates = TabManagerDelegate::GetSortedCandidates(tab_list, arc_processes);
   ASSERT_EQ(9U, candidates.size());
 
   // focused app.
   ASSERT_TRUE(candidates[0].app());
   EXPECT_EQ("focused", candidates[0].app()->process_name());
   // visible app 1, last_activity_time larger than visible app 2.
   ASSERT_TRUE(candidates[1].app());
   EXPECT_EQ("visible1", candidates[1].app()->process_name());
   // visible app 2, last_activity_time less than visible app 1.
   ASSERT_TRUE(candidates[2].app());
@@ skipping 44 matching lines @@
  public:
   MockTabManagerDelegate()
       : TabManagerDelegate(nullptr),
         always_return_true_from_is_recently_killed_(false) {}
 
   explicit MockTabManagerDelegate(TabManagerDelegate::MemoryStat* mem_stat)
       : TabManagerDelegate(nullptr, mem_stat),
         always_return_true_from_is_recently_killed_(false) {}
 
   // unit test.
-  std::vector<int> GetKilledArcProcesses() {
-    return killed_arc_processes_;
-  }
+  std::vector<int> GetKilledArcProcesses() { return killed_arc_processes_; }
 
   // unit test.
-  std::vector<int64_t> GetKilledTabs() {
-    return killed_tabs_;
-  }
+  std::vector<int64_t> GetKilledTabs() { return killed_tabs_; }
 
   // unit test.
   void Clear() {
     killed_arc_processes_.clear();
     killed_tabs_.clear();
   }
 
   // unit test.
   void set_always_return_true_from_is_recently_killed(
       bool always_return_true_from_is_recently_killed) {
@@ skipping 28 matching lines @@
   std::vector<int> killed_arc_processes_;
   std::vector<int64_t> killed_tabs_;
   bool always_return_true_from_is_recently_killed_;
 };
 
 class MockMemoryStat : public TabManagerDelegate::MemoryStat {
  public:
   MockMemoryStat() {}
   ~MockMemoryStat() override {}
 
-  int TargetMemoryToFreeKB() override {
-    return target_memory_to_free_kb_;
-  }
+  int TargetMemoryToFreeKB() override { return target_memory_to_free_kb_; }
 
   int EstimatedMemoryFreedKB(base::ProcessHandle pid) override {
     return process_pss_[pid];
   }
 
   // unittest.
   void SetTargetMemoryToFreeKB(const int target) {
     target_memory_to_free_kb_ = target;
   }
 
@@ skipping 238 matching lines @@
   EXPECT_EQ(1, killed_tabs[2]);
 
   // Check that killed apps are in the map.
   const TabManagerDelegate::KilledArcProcessesMap& processes_map =
       tab_manager_delegate.recently_killed_arc_processes_;
   EXPECT_EQ(2U, processes_map.size());
   EXPECT_EQ(1U, processes_map.count("service"));
   EXPECT_EQ(1U, processes_map.count("not-visible"));
 }
 
-}  // namespace memory
+}  // namespace resource_coordinator