Use ExtensionEnableFlow for shim initiated launches. (Mac)

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;
 
 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(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*));
 
   MOCK_METHOD0(MaybeTerminate, void());
 
   void CaptureLoadProfileCallback(
       const base::FilePath& path,
       base::Callback<void(Profile*)> callback) {
     callbacks_[path] = callback;
   }
 
   bool RunLoadProfileCallback(
       const base::FilePath& path,
       Profile* profile) {
     callbacks_[path].Run(profile);
     return callbacks_.erase(path);
   }
 
+  void RunCallback(const base::Callback<void()>& callback) {
+    callback.Run();
+  }
+
  private:
   std::map<base::FilePath,
            base::Callback<void(Profile*)> > callbacks_;
 };
 
 class TestingExtensionAppShimHandler : public ExtensionAppShimHandler {
  public:
   TestingExtensionAppShimHandler(Delegate* delegate) {
     set_delegate(delegate);
   }
@@ skipping 131 matching lines @@
   FakeHost host_ab_;
   FakeHost host_bb_;
   FakeHost host_aa_duplicate_;
   scoped_refptr<Extension> extension_a_;
   scoped_refptr<Extension> extension_b_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ExtensionAppShimHandlerTest);
 };
 
-TEST_F(ExtensionAppShimHandlerTest, LaunchFailure) {
+TEST_F(ExtensionAppShimHandlerTest, LaunchProfileNotFound) {
   // Bad profile path.
   EXPECT_CALL(*delegate_, ProfileExistsForPath(profile_path_a_))
       .WillOnce(Return(false))
       .WillRepeatedly(Return(true));
   EXPECT_CALL(host_aa_, OnAppLaunchComplete(APP_SHIM_LAUNCH_PROFILE_NOT_FOUND));
   NormalLaunch(&host_aa_);
+}
 
+TEST_F(ExtensionAppShimHandlerTest, LaunchAppNotFound) {
+  // App not found.
+  EXPECT_CALL(*delegate_, GetAppExtension(&profile_a_, kTestAppIdA))
+      .WillRepeatedly(Return(static_cast<const Extension*>(NULL)));
+  EXPECT_CALL(*delegate_, EnableExtension(&profile_a_, kTestAppIdA, _))
+      .WillOnce(WithArgs<2>(Invoke(delegate_, &MockDelegate::RunCallback)));
+  EXPECT_CALL(host_aa_, OnAppLaunchComplete(APP_SHIM_LAUNCH_APP_NOT_FOUND));
+  NormalLaunch(&host_aa_);
+}
+
+TEST_F(ExtensionAppShimHandlerTest, LaunchAppNotEnabled) {
   // App not found.
   EXPECT_CALL(*delegate_, GetAppExtension(&profile_a_, kTestAppIdA))
       .WillOnce(Return(static_cast<const Extension*>(NULL)))
       .WillRepeatedly(Return(extension_a_.get()));
-  EXPECT_CALL(host_aa_, OnAppLaunchComplete(APP_SHIM_LAUNCH_APP_NOT_FOUND));
+  EXPECT_CALL(*delegate_, EnableExtension(&profile_a_, kTestAppIdA, _))
+      .WillOnce(WithArgs<2>(Invoke(delegate_, &MockDelegate::RunCallback)));
   NormalLaunch(&host_aa_);
 }
 
 TEST_F(ExtensionAppShimHandlerTest, LaunchAndCloseShim) {
   // Normal startup.
   NormalLaunch(&host_aa_);
   EXPECT_EQ(&host_aa_, handler_->FindHost(&profile_a_, kTestAppIdA));
 
   NormalLaunch(&host_ab_);
   EXPECT_EQ(&host_ab_, handler_->FindHost(&profile_a_, kTestAppIdB));
@@ skipping 131 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