cros: Fix race on feedback extension loading

chrome/browser/chromeos/login/ui/login_feedback.cc

 // Copyright 2016 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/chromeos/login/ui/login_feedback.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
+#include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "chrome/browser/chromeos/login/ui/login_display_host.h"
 #include "chrome/browser/extensions/api/feedback_private/feedback_private_api.h"
 #include "chrome/browser/extensions/component_loader.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/grit/browser_resources.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "extensions/browser/app_window/app_window.h"
 #include "extensions/browser/app_window/app_window_registry.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/process_manager_observer.h"
 #include "extensions/common/extension.h"
 #include "ui/aura/window.h"
 #include "ui/views/widget/widget.h"
@@ skipping 23 matching lines @@
                                 public content::WebContentsObserver {
  public:
   // Loads the feedback extension on the given profile and invokes
   // |on_ready_callback| when it is ready.
   static void Load(Profile* profile, const base::Closure& on_ready_callback);
 
  private:
   explicit FeedbackExtensionLoader(Profile* profile);
   ~FeedbackExtensionLoader() override;
 
+  void Initialize();
+
   void AddOnReadyCallback(const base::Closure& on_ready_callback);
   void RunOnReadyCallbacks();
 
   // extensions::ProcessManagerObserver
   void OnBackgroundHostCreated(extensions::ExtensionHost* host) override;
   void OnBackgroundHostClose(const std::string& extension_id) override;
 
   // content::WebContentsObserver
   void DocumentOnLoadCompletedInMainFrame() override;
 
   Profile* const profile_;
   std::vector<base::Closure> on_ready_callbacks_;
   bool ready_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(FeedbackExtensionLoader);
 };
 
 // Current live instance of FeedbackExtensionLoader.
 FeedbackExtensionLoader* instance = nullptr;
 
 // static
 void FeedbackExtensionLoader::Load(Profile* profile,
                                    const base::Closure& on_ready_callback) {
-  if (instance == nullptr)
+  if (instance == nullptr) {
     instance = new FeedbackExtensionLoader(profile);
+    instance->Initialize();
+  }
 
   DCHECK_EQ(instance->profile_, profile);
   DCHECK(!on_ready_callback.is_null());
   instance->AddOnReadyCallback(on_ready_callback);
 }
 
 FeedbackExtensionLoader::FeedbackExtensionLoader(Profile* profile)
-    : profile_(profile) {
-  extensions::ComponentLoader* component_loader = GetComponentLoader(profile_);
-  DCHECK(!component_loader->Exists(extension_misc::kFeedbackExtensionId))
-      << "Feedback extension should not be loaded in signin profile by default";
-  component_loader->Add(IDR_FEEDBACK_MANIFEST,
-                        base::FilePath(FILE_PATH_LITERAL("feedback")));
-
-  extensions::ProcessManager* pm = GetProcessManager(profile_);
-  pm->AddObserver(this);
-  DCHECK(
-      !pm->GetBackgroundHostForExtension(extension_misc::kFeedbackExtensionId));
-}
+    : profile_(profile) {}
 
 FeedbackExtensionLoader::~FeedbackExtensionLoader() {
   DCHECK_EQ(instance, this);
   instance = nullptr;
 
   GetProcessManager(profile_)->RemoveObserver(this);
   GetComponentLoader(profile_)->Remove(extension_misc::kFeedbackExtensionId);
 }
 
+void FeedbackExtensionLoader::Initialize() {
+  extensions::ProcessManager* pm = GetProcessManager(profile_);
+  pm->AddObserver(this);
+  extensions::ExtensionHost* const host =
+      pm->GetBackgroundHostForExtension(extension_misc::kFeedbackExtensionId);
+  if (host) {
+    OnBackgroundHostCreated(host);
+    if (!host->host_contents()->IsLoading())
+      DocumentOnLoadCompletedInMainFrame();
+    return;
+  }
+
+  extensions::ComponentLoader* component_loader = GetComponentLoader(profile_);
+  if (!component_loader->Exists(extension_misc::kFeedbackExtensionId)) {
+    component_loader->Add(IDR_FEEDBACK_MANIFEST,
+                          base::FilePath(FILE_PATH_LITERAL("feedback")));
+  }
+}
+
 void FeedbackExtensionLoader::AddOnReadyCallback(
     const base::Closure& on_ready_callback) {
   on_ready_callbacks_.push_back(on_ready_callback);
   if (ready_)
     RunOnReadyCallbacks();
 }
 
 void FeedbackExtensionLoader::RunOnReadyCallbacks() {
   std::vector<base::Closure> callbacks;
   callbacks.swap(on_ready_callbacks_);
@@ skipping 108 matching lines @@
 void LoginFeedback::EnsureFeedbackUI() {
   // Bail if any feedback app window is opened.
   if (feedback_window_handler_->HasFeedbackAppWindow())
     return;
 
   extensions::FeedbackPrivateAPI* api =
       extensions::FeedbackPrivateAPI::GetFactoryInstance()->Get(profile_);
   api->RequestFeedbackForFlow(
       description_, "Login", GURL(),
       extensions::api::feedback_private::FeedbackFlow::FEEDBACK_FLOW_LOGIN);
+
+  // Make sure there is a feedback app window opened.
+  base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&LoginFeedback::EnsureFeedbackUI, weak_factory_.GetWeakPtr()),
+      base::TimeDelta::FromSeconds(1));
 }
 
 void LoginFeedback::OnFeedbackFinished() {
   if (!finished_callback_.is_null())
     finished_callback_.Run();
 }
 
 }  // namespace chromeos