Wait for URLBlacklist update tasks on automation tests.

chrome/browser/automation/testing_automation_provider.cc

 // Copyright (c) 2011 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/automation/testing_automation_provider.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 159 matching lines @@
   }
 
   virtual std::string GetHTMLContents() { return contents_; }
 
  private:
   const std::string contents_;
 
   DISALLOW_COPY_AND_ASSIGN(AutomationInterstitialPage);
 };
 
+// Helper function for nested Binds that resolves the overloading of
+// BrowserThread::PostTask, and ignores the return value.
+void PostTask(BrowserThread::ID id, const base::Closure& task) {
+  BrowserThread::PostTask(id, FROM_HERE, task);
+}
+
 }  // namespace
 
 TestingAutomationProvider::TestingAutomationProvider(Profile* profile)
     : AutomationProvider(profile),
 #if defined(TOOLKIT_VIEWS)
       popup_menu_waiter_(NULL),
 #endif
       redirect_query_(0) {
   BrowserList::AddObserver(this);
   registrar_.Add(this, chrome::NOTIFICATION_SESSION_END,
@@ skipping 2525 matching lines @@
         infobar_helper->RemoveInfoBar(infobar);
     }
     reply.SendSuccess(NULL);
     return;
   }
   reply.SendError("Invalid action");
 }
 
 namespace {
 
-// Task to get info about BrowserChildProcessHost. Must run on IO thread to
+// Gets info about BrowserChildProcessHost. Must run on IO thread to
 // honor the semantics of BrowserChildProcessHost.
 // Used by AutomationProvider::GetBrowserInfo().
-class GetChildProcessHostInfoTask : public Task {
- public:
-  GetChildProcessHostInfoTask(base::WaitableEvent* event,
-                              ListValue* child_processes)
-    : event_(event),
-      child_processes_(child_processes) {}
-
-  virtual void Run() {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-    for (BrowserChildProcessHost::Iterator iter; !iter.Done(); ++iter) {
-      // Only add processes which are already started,
-      // since we need their handle.
-      if ((*iter)->handle() == base::kNullProcessHandle) {
-        continue;
-      }
-      ChildProcessInfo* info = *iter;
-      DictionaryValue* item = new DictionaryValue;
-      item->SetString("name", info->name());
-      item->SetString("type",
-                      ChildProcessInfo::GetTypeNameInEnglish(info->type()));
-      item->SetInteger("pid", base::GetProcId(info->handle()));
-      child_processes_->Append(item);
-    }
-    event_->Signal();
+void GetChildProcessHostInfo(ListValue* child_processes) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  for (BrowserChildProcessHost::Iterator iter; !iter.Done(); ++iter) {
+    // Only add processes which are already started,
+    // since we need their handle.
+    if ((*iter)->handle() == base::kNullProcessHandle)
+      continue;
+    ChildProcessInfo* info = *iter;
+    DictionaryValue* item = new DictionaryValue;
+    item->SetString("name", info->name());
+    item->SetString("type",
+                    ChildProcessInfo::GetTypeNameInEnglish(info->type()));
+    item->SetInteger("pid", base::GetProcId(info->handle()));
+    child_processes->Append(item);
   }
-
- private:
-  base::WaitableEvent* const event_;  // weak
-  ListValue* child_processes_;
-
-  DISALLOW_COPY_AND_ASSIGN(GetChildProcessHostInfoTask);
-};
+}
 
 }  // namespace
 
 // Sample json input: { "command": "GetBrowserInfo" }
 // Refer to GetBrowserInfo() in chrome/test/pyautolib/pyauto.py for
 // sample json output.
 void TestingAutomationProvider::GetBrowserInfo(
     DictionaryValue* args,
     IPC::Message* reply_message) {
   base::ThreadRestrictions::ScopedAllowIO allow_io;  // needed for PathService
@@ skipping 91 matching lines @@
     windows->Append(browser_item);
   }
   return_value->Set("windows", windows);
 
 #if defined(OS_LINUX)
   int flags = ChildProcessHost::CHILD_ALLOW_SELF;
 #else
   int flags = ChildProcessHost::CHILD_NORMAL;
 #endif
 
-  return_value->SetString("child_process_path",
-                          ChildProcessHost::GetChildPath(flags).value());
-  // Child processes are the processes for plugins and other workers.
-  // Add all child processes in a list of dictionaries, one dictionary item
-  // per child process.
-  ListValue* child_processes = new ListValue;
-  base::WaitableEvent event(true   /* manual reset */,
-                            false  /* not initially signaled */);
-  CHECK(BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      new GetChildProcessHostInfoTask(&event, child_processes)));
-  event.Wait();
-  return_value->Set("child_processes", child_processes);
-
   // Add all extension processes in a list of dictionaries, one dictionary
   // item per extension process.
   ListValue* extension_views = new ListValue;
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   std::vector<Profile*> profiles(profile_manager->GetLoadedProfiles());
   for (size_t i = 0; i < profiles.size(); ++i) {
     ExtensionProcessManager* process_manager =
         profiles[i]->GetExtensionProcessManager();
     if (!process_manager)
       continue;
@@ skipping 35 matching lines @@
           type = "unknown";
           break;
       }
       item->SetString("view_type", type);
       item->SetString("url", ex_host->GetURL().spec());
       item->SetBoolean("loaded", ex_host->did_stop_loading());
       extension_views->Append(item);
     }
   }
   return_value->Set("extension_views", extension_views);
-  AutomationJSONReply(this, reply_message).SendSuccess(return_value.get());
+
+  return_value->SetString("child_process_path",
+                          ChildProcessHost::GetChildPath(flags).value());
+  // Child processes are the processes for plugins and other workers.
+  // Add all child processes in a list of dictionaries, one dictionary item
+  // per child process.
+  ListValue* child_processes = new ListValue;
+  return_value->Set("child_processes", child_processes);
+  BrowserThread::PostTaskAndReply(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&GetChildProcessHostInfo, child_processes),
+      base::Bind(&AutomationJSONReply::SendSuccess,
+                 base::Owned(new AutomationJSONReply(this, reply_message)),
+                 base::Owned(return_value.release())));
 }
 
 // Sample json input: { "command": "GetProcessInfo" }
 // Refer to GetProcessInfo() in chrome/test/pyautolib/pyauto.py for
 // sample json output.
 void TestingAutomationProvider::GetProcessInfo(
     DictionaryValue* args,
     IPC::Message* reply_message) {
   scoped_refptr<ProcessInfoObserver>
       proc_observer(new ProcessInfoObserver(this, reply_message));
@@ skipping 2905 matching lines @@
     return;
   }
 
   // This class will send the message immediately if no tab is loading.
   new AllTabsStoppedLoadingObserver(this, reply_message);
 }
 
 void TestingAutomationProvider::SetPolicies(
     DictionaryValue* args,
     IPC::Message* reply_message) {
-  AutomationJSONReply reply(this, reply_message);
+  scoped_ptr<AutomationJSONReply> reply(
+      new AutomationJSONReply(this, reply_message));
 
 #if !defined(ENABLE_CONFIGURATION_POLICY) || defined(OFFICIAL_BUILD)
-  reply.SendError("Configuration Policy disabled");
+  reply->SendError("Configuration Policy disabled");
 #else
   const policy::PolicyDefinitionList* list =
       policy::GetChromePolicyDefinitionList();
   policy::BrowserPolicyConnector* connector =
       g_browser_process->browser_policy_connector();
   struct {
     std::string name;
     policy::ConfigurationPolicyProvider* provider;
   } providers[] = {
     { "managed_cloud",        connector->GetManagedCloudProvider()        },
     { "managed_platform",     connector->GetManagedPlatformProvider()     },
     { "recommended_cloud",    connector->GetRecommendedCloudProvider()    },
     { "recommended_platform", connector->GetRecommendedPlatformProvider() }
   };
   // Verify if all the requested providers exist before changing anything.
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(providers); ++i) {
     DictionaryValue* policies = NULL;
     if (args->GetDictionary(providers[i].name, &policies) &&
         policies &&
         !providers[i].provider) {
-      reply.SendError("Provider not available: " + providers[i].name);
+      reply->SendError("Provider not available: " + providers[i].name);
       return;
     }
   }
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(providers); ++i) {
     DictionaryValue* policies = NULL;
     if (args->GetDictionary(providers[i].name, &policies) && policies) {
       policy::PolicyMap* map = new policy::PolicyMap;
       map->LoadFrom(policies, list);
       providers[i].provider->OverridePolicies(map);
     }
   }
 
-  reply.SendSuccess(NULL);
+  // OverridePolicies() triggers preference updates, which triggers preference
+  // listeners. Some policies (e.g. URLBlacklist) post tasks to other message
+  // loops before they start being enforced; make sure those tasks have
+  // finished.
+  // Updates of the URLBlacklist are done on IO, after building the blacklist
+  // on FILE, which is initiated from IO.
+  PostTask(BrowserThread::IO,
+      base::Bind(&PostTask, BrowserThread::FILE,
+          base::Bind(&PostTask, BrowserThread::IO,
+              base::Bind(&PostTask, BrowserThread::UI,
+                  base::Bind(&AutomationJSONReply::SendSuccess,
+                             base::Owned(reply.release()),
+                             static_cast<const Value*>(NULL))))));
 #endif  // defined(OFFICIAL_BUILD)
 }
 
 void TestingAutomationProvider::GetPolicyDefinitionList(
     DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
 
 #if !defined(ENABLE_CONFIGURATION_POLICY)
   reply.SendError("Configuration Policy disabled");
@@ skipping 613 matching lines @@
 
   Send(reply_message_);
   redirect_query_ = 0;
   reply_message_ = NULL;
 }
 
 void TestingAutomationProvider::OnRemoveProvider() {
   if (g_browser_process)
     g_browser_process->GetAutomationProviderList()->RemoveProvider(this);
 }