Rename apps::ShellWindow to apps::AppWindow

apps/app_shim/extension_app_shim_handler_mac_unittest.cc

 // Copyright 2013 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 "apps/app_shim/extension_app_shim_handler_mac.h"
 
 #include <vector>
 
 #include "apps/app_shim/app_shim_host_mac.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/browser/notification_service.h"
 #include "extensions/common/extension.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace apps {
 
 using extensions::Extension;
-typedef ShellWindowRegistry::ShellWindowList ShellWindowList;
+typedef AppWindowRegistry::AppWindowList AppWindowList;
 
 using ::testing::_;
 using ::testing::Invoke;
 using ::testing::Return;
 using ::testing::WithArgs;
 
 class MockDelegate : public ExtensionAppShimHandler::Delegate {
  public:
   virtual ~MockDelegate() {}
 
   MOCK_METHOD1(ProfileExistsForPath, bool(const base::FilePath&));
   MOCK_METHOD1(ProfileForPath, Profile*(const base::FilePath&));
   MOCK_METHOD2(LoadProfileAsync,
                void(const base::FilePath&,
                     base::Callback<void(Profile*)>));
 
-  MOCK_METHOD2(GetWindows, ShellWindowList(Profile*, const std::string&));
+  MOCK_METHOD2(GetWindows, AppWindowList(Profile*, const std::string&));
 
   MOCK_METHOD2(GetAppExtension, const Extension*(Profile*, const std::string&));
   MOCK_METHOD3(EnableExtension, void(Profile*,
                                      const std::string&,
                                      const base::Callback<void()>&));
   MOCK_METHOD3(LaunchApp,
                void(Profile*,
                     const Extension*,
                     const std::vector<base::FilePath>&));
   MOCK_METHOD2(LaunchShim, void(Profile*, const Extension*));
@@ skipping 119 matching lines @@
         .WillRepeatedly(Return(true));
     EXPECT_CALL(*delegate_, ProfileForPath(profile_path_a_))
         .WillRepeatedly(Return(&profile_a_));
     EXPECT_CALL(*delegate_, ProfileExistsForPath(profile_path_b_))
         .WillRepeatedly(Return(true));
     EXPECT_CALL(*delegate_, ProfileForPath(profile_path_b_))
         .WillRepeatedly(Return(&profile_b_));
 
     // In most tests, we don't care about the result of GetWindows, it just
     // needs to be non-empty.
-    ShellWindowList shell_window_list;
-    shell_window_list.push_back(static_cast<ShellWindow*>(NULL));
+    AppWindowList app_window_list;
+    app_window_list.push_back(static_cast<AppWindow*>(NULL));
     EXPECT_CALL(*delegate_, GetWindows(_, _))
-        .WillRepeatedly(Return(shell_window_list));
+        .WillRepeatedly(Return(app_window_list));
 
     EXPECT_CALL(*delegate_, GetAppExtension(_, kTestAppIdA))
         .WillRepeatedly(Return(extension_a_.get()));
     EXPECT_CALL(*delegate_, GetAppExtension(_, kTestAppIdB))
         .WillRepeatedly(Return(extension_b_.get()));
     EXPECT_CALL(*delegate_, LaunchApp(_, _, _))
         .WillRepeatedly(Return());
   }
 
   void NormalLaunch(AppShimHandler::Host* host) {
@@ skipping 103 matching lines @@
 
   // Normal shim launch adds an entry in the map.
   // App should not be launched here, but return success to the shim.
   EXPECT_CALL(*delegate_,
               LaunchApp(&profile_a_, extension_a_.get(), _))
       .Times(0);
   EXPECT_CALL(host_aa_, OnAppLaunchComplete(APP_SHIM_LAUNCH_SUCCESS));
   RegisterOnlyLaunch(&host_aa_);
   EXPECT_EQ(&host_aa_, handler_->FindHost(&profile_a_, kTestAppIdA));
 
-  // Return no shell windows for OnShimFocus and OnShimQuit.
-  ShellWindowList shell_window_list;
+  // Return no app windows for OnShimFocus and OnShimQuit.
+  AppWindowList app_window_list;
   EXPECT_CALL(*delegate_, GetWindows(&profile_a_, kTestAppIdA))
-      .WillRepeatedly(Return(shell_window_list));
+      .WillRepeatedly(Return(app_window_list));
 
   // Non-reopen focus does nothing.
   EXPECT_CALL(*handler_, OnShimFocus(&host_aa_, APP_SHIM_FOCUS_NORMAL, _))
       .WillOnce(Invoke(handler_.get(),
                        &TestingExtensionAppShimHandler::RealOnShimFocus));
   EXPECT_CALL(*delegate_,
               LaunchApp(&profile_a_, extension_a_.get(), _))
       .Times(0);
   handler_->OnShimFocus(&host_aa_,
                         APP_SHIM_FOCUS_NORMAL,
@@ skipping 25 matching lines @@
   // Launch shims, adding entries in the map.
   EXPECT_CALL(host_aa_, OnAppLaunchComplete(APP_SHIM_LAUNCH_SUCCESS));
   RegisterOnlyLaunch(&host_aa_);
   EXPECT_EQ(&host_aa_, handler_->FindHost(&profile_a_, kTestAppIdA));
 
   EXPECT_CALL(host_ab_, OnAppLaunchComplete(APP_SHIM_LAUNCH_SUCCESS));
   RegisterOnlyLaunch(&host_ab_);
   EXPECT_EQ(&host_ab_, handler_->FindHost(&profile_a_, kTestAppIdB));
 
   // Return empty window list.
-  ShellWindowList shell_window_list;
+  AppWindowList app_window_list;
   EXPECT_CALL(*delegate_, GetWindows(_, _))
-      .WillRepeatedly(Return(shell_window_list));
+      .WillRepeatedly(Return(app_window_list));
 
   // Quitting when there's another shim should not terminate.
   EXPECT_CALL(*delegate_, MaybeTerminate())
       .Times(0);
   handler_->OnAppDeactivated(&profile_a_, kTestAppIdA);
 
   // Quitting when it's the last shim should terminate.
   EXPECT_CALL(*delegate_, MaybeTerminate());
   handler_->OnAppDeactivated(&profile_a_, kTestAppIdB);
 }
@@ skipping 20 matching lines @@
       .WillRepeatedly(Return(&profile_a_));
   EXPECT_CALL(*delegate_, LoadProfileAsync(profile_path_a_, _))
       .WillOnce(Invoke(delegate_, &MockDelegate::CaptureLoadProfileCallback));
   NormalLaunch(&host_aa_);
   EXPECT_FALSE(handler_->FindHost(&profile_a_, kTestAppIdA));
   delegate_->RunLoadProfileCallback(profile_path_a_, &profile_a_);
   EXPECT_TRUE(handler_->FindHost(&profile_a_, kTestAppIdA));
 }
 
 }  // namespace apps