Remove MessageLoop::current()->RunUntilIdle() in components.

components/dom_distiller/core/distiller_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 "components/dom_distiller/core/distiller.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <map>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "components/dom_distiller/core/article_distillation_update.h"
 #include "components/dom_distiller/core/distiller_page.h"
 #include "components/dom_distiller/core/fake_distiller_page.h"
 #include "components/dom_distiller/core/proto/distilled_article.pb.h"
 #include "components/dom_distiller/core/proto/distilled_page.pb.h"
 #include "net/url_request/url_request_context_getter.h"
@@ skipping 309 matching lines @@
   return std::unique_ptr<DistillerPage>(distiller_page);
 }
 
 TEST_F(DistillerTest, DistillPage) {
   base::MessageLoopForUI loop;
   std::unique_ptr<base::Value> result =
       CreateDistilledValueReturnedFromJS(kTitle, kContent, vector<int>(), "");
   distiller_.reset(
       new DistillerImpl(url_fetcher_factory_, DomDistillerOptions()));
   DistillPage(kURL, CreateMockDistillerPage(result.get(), GURL(kURL)));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kTitle, article_proto_->title());
   ASSERT_EQ(article_proto_->pages_size(), 1);
   const DistilledPageProto& first_page = article_proto_->pages(0);
   EXPECT_EQ(kContent, first_page.html());
   EXPECT_EQ(kURL, first_page.url());
 }
 
 TEST_F(DistillerTest, DistillPageWithDebugInfo) {
   base::MessageLoopForUI loop;
   DomDistillerResult dd_result;
   dd_result.mutable_debug_info()->set_log(kDebugLog);
   std::unique_ptr<base::Value> result =
       dom_distiller::proto::json::DomDistillerResult::WriteToValue(dd_result);
   distiller_.reset(
       new DistillerImpl(url_fetcher_factory_, DomDistillerOptions()));
   DistillPage(kURL, CreateMockDistillerPage(result.get(), GURL(kURL)));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   const DistilledPageProto& first_page = article_proto_->pages(0);
   EXPECT_EQ(kDebugLog, first_page.debug_info().log());
 }
 
 void SetTimingEntry(TimingEntry* entry, const std::string& name, double time) {
   entry->set_name(name);
   entry->set_time(time);
 }
 
 TEST_F(DistillerTest, DistillPageWithTimingInfo) {
   base::MessageLoopForUI loop;
   DomDistillerResult dd_result;
   dd_result.mutable_timing_info()->set_total_time(1.0);
   dd_result.mutable_timing_info()->set_markup_parsing_time(2.0);
   dd_result.mutable_timing_info()->set_document_construction_time(3.0);
   dd_result.mutable_timing_info()->set_article_processing_time(4.0);
   dd_result.mutable_timing_info()->set_formatting_time(5.0);
   SetTimingEntry(
       dd_result.mutable_timing_info()->add_other_times(), "time0", 6.0);
   SetTimingEntry(
       dd_result.mutable_timing_info()->add_other_times(), "time1", 7.0);
   std::unique_ptr<base::Value> result =
       dom_distiller::proto::json::DomDistillerResult::WriteToValue(dd_result);
   distiller_.reset(
       new DistillerImpl(url_fetcher_factory_, DomDistillerOptions()));
   DistillPage(kURL, CreateMockDistillerPage(result.get(), GURL(kURL)));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   const DistilledPageProto& first_page = article_proto_->pages(0);
   std::map<std::string, double> timings;
   for (int i = 0; i < first_page.timing_info_size(); ++i) {
     DistilledPageProto::TimingInfo timing = first_page.timing_info(i);
     timings[timing.name()] = timing.time();
   }
   EXPECT_EQ(7u, timings.size());
   EXPECT_EQ(1.0, timings["total"]);
   EXPECT_EQ(2.0, timings["markup_parsing"]);
   EXPECT_EQ(3.0, timings["document_construction"]);
   EXPECT_EQ(4.0, timings["article_processing"]);
   EXPECT_EQ(5.0, timings["formatting"]);
   EXPECT_EQ(6.0, timings["time0"]);
   EXPECT_EQ(7.0, timings["time1"]);
 }
 
 TEST_F(DistillerTest, DistillPageWithImages) {
   base::MessageLoopForUI loop;
   vector<int> image_indices;
   image_indices.push_back(0);
   image_indices.push_back(1);
   image_indices.push_back(2);
   std::unique_ptr<base::Value> result =
       CreateDistilledValueReturnedFromJS(kTitle, kContent, image_indices, "");
   distiller_.reset(
       new DistillerImpl(url_fetcher_factory_, DomDistillerOptions()));
   DistillPage(kURL, CreateMockDistillerPage(result.get(), GURL(kURL)));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kTitle, article_proto_->title());
   ASSERT_EQ(article_proto_->pages_size(), 1);
   const DistilledPageProto& first_page = article_proto_->pages(0);
   EXPECT_EQ(kContent, first_page.html());
   EXPECT_EQ(kURL, first_page.url());
   ASSERT_EQ(2, first_page.image_size());
   EXPECT_EQ(kImageData[0], first_page.image(0).data());
   EXPECT_EQ(kImageURLs[0], first_page.image(0).url());
   EXPECT_EQ(GetImageName(1, 0), first_page.image(0).name());
   EXPECT_EQ(kImageData[1], first_page.image(1).data());
@@ skipping 17 matching lines @@
       image_indices.push_back(next_image_number);
       next_image_number = (next_image_number + 1) % kTotalImages;
     }
     distiller_data->image_ids.push_back(image_indices);
   }
 
   distiller_.reset(
       new DistillerImpl(url_fetcher_factory_, DomDistillerOptions()));
   DistillPage(distiller_data->page_urls[0],
               CreateMockDistillerPages(distiller_data.get(), kNumPages, 0));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   VerifyArticleProtoMatchesMultipageData(
       article_proto_.get(), distiller_data.get(), kNumPages, kNumPages);
 }
 
 TEST_F(DistillerTest, DistillLinkLoop) {
   base::MessageLoopForUI loop;
   // Create a loop, the next page is same as the current page. This could
   // happen if javascript misparses a next page link.
   std::unique_ptr<base::Value> result =
       CreateDistilledValueReturnedFromJS(kTitle, kContent, vector<int>(), kURL);
   distiller_.reset(
       new DistillerImpl(url_fetcher_factory_, DomDistillerOptions()));
   DistillPage(kURL, CreateMockDistillerPage(result.get(), GURL(kURL)));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kTitle, article_proto_->title());
   EXPECT_EQ(article_proto_->pages_size(), 1);
 }
 
 TEST_F(DistillerTest, CheckMaxPageLimitExtraPage) {
   base::MessageLoopForUI loop;
   const size_t kMaxPagesInArticle = 10;
   std::unique_ptr<MultipageDistillerData> distiller_data =
       CreateMultipageDistillerDataWithoutImages(kMaxPagesInArticle);
 
   // Note: Next page url of the last page of article is set. So distiller will
   // try to do kMaxPagesInArticle + 1 calls if the max article limit does not
   // work.
   std::unique_ptr<base::Value> last_page_data =
       CreateDistilledValueReturnedFromJS(
           kTitle, distiller_data->content[kMaxPagesInArticle - 1],
           vector<int>(), "", distiller_data->page_urls[kMaxPagesInArticle - 2]);
 
   distiller_data->distilled_values.pop_back();
   distiller_data->distilled_values.push_back(last_page_data.release());
 
   distiller_.reset(
       new DistillerImpl(url_fetcher_factory_, DomDistillerOptions()));
 
   distiller_->SetMaxNumPagesInArticle(kMaxPagesInArticle);
 
   DistillPage(
       distiller_data->page_urls[0],
       CreateMockDistillerPages(distiller_data.get(), kMaxPagesInArticle, 0));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kTitle, article_proto_->title());
   EXPECT_EQ(kMaxPagesInArticle,
             static_cast<size_t>(article_proto_->pages_size()));
 }
 
 TEST_F(DistillerTest, CheckMaxPageLimitExactLimit) {
   base::MessageLoopForUI loop;
   const size_t kMaxPagesInArticle = 10;
   std::unique_ptr<MultipageDistillerData> distiller_data =
       CreateMultipageDistillerDataWithoutImages(kMaxPagesInArticle);
 
   distiller_.reset(
       new DistillerImpl(url_fetcher_factory_, DomDistillerOptions()));
 
   // Check if distilling an article with exactly the page limit works.
   distiller_->SetMaxNumPagesInArticle(kMaxPagesInArticle);
 
   DistillPage(
       distiller_data->page_urls[0],
       CreateMockDistillerPages(distiller_data.get(), kMaxPagesInArticle, 0));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kTitle, article_proto_->title());
   EXPECT_EQ(kMaxPagesInArticle,
             static_cast<size_t>(article_proto_->pages_size()));
 }
 
 TEST_F(DistillerTest, SinglePageDistillationFailure) {
   base::MessageLoopForUI loop;
   // To simulate failure return a null value.
   std::unique_ptr<base::Value> null_value = base::Value::CreateNullValue();
   distiller_.reset(
       new DistillerImpl(url_fetcher_factory_, DomDistillerOptions()));
   DistillPage(kURL, CreateMockDistillerPage(null_value.get(), GURL(kURL)));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ("", article_proto_->title());
   EXPECT_EQ(0, article_proto_->pages_size());
 }
 
 TEST_F(DistillerTest, MultiplePagesDistillationFailure) {
   base::MessageLoopForUI loop;
   const size_t kNumPages = 8;
   std::unique_ptr<MultipageDistillerData> distiller_data =
       CreateMultipageDistillerDataWithoutImages(kNumPages);
 
   // The page number of the failed page.
   size_t failed_page_num = 3;
   // reset distilled data of the failed page.
   distiller_data->distilled_values.erase(
       distiller_data->distilled_values.begin() + failed_page_num);
   distiller_data->distilled_values.insert(
       distiller_data->distilled_values.begin() + failed_page_num,
       base::Value::CreateNullValue().release());
   // Expect only calls till the failed page number.
   distiller_.reset(
       new DistillerImpl(url_fetcher_factory_, DomDistillerOptions()));
   DistillPage(
       distiller_data->page_urls[0],
       CreateMockDistillerPages(distiller_data.get(), failed_page_num + 1, 0));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kTitle, article_proto_->title());
   VerifyArticleProtoMatchesMultipageData(
       article_proto_.get(), distiller_data.get(), failed_page_num, kNumPages);
 }
 
 TEST_F(DistillerTest, DistillMultiplePagesFirstEmpty) {
   base::MessageLoopForUI loop;
   const size_t kNumPages = 8;
   std::unique_ptr<MultipageDistillerData> distiller_data =
       CreateMultipageDistillerDataWithoutImages(kNumPages);
 
   // The first page has no content.
   const size_t empty_page_num = 0;
   distiller_data->content[empty_page_num] = "";
   std::unique_ptr<base::Value> distilled_value =
       CreateDistilledValueReturnedFromJS(kTitle, "", vector<int>(),
       GenerateNextPageUrl(kURL, empty_page_num, kNumPages),
       GeneratePrevPageUrl(kURL, empty_page_num));
   // Reset distilled data of the first page.
   distiller_data->distilled_values.erase(
       distiller_data->distilled_values.begin() + empty_page_num);
   distiller_data->distilled_values.insert(
       distiller_data->distilled_values.begin() + empty_page_num,
       distilled_value.release());
 
   distiller_.reset(
       new DistillerImpl(url_fetcher_factory_, DomDistillerOptions()));
   DistillPage(distiller_data->page_urls[0],
               CreateMockDistillerPages(distiller_data.get(), 1, 0));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   // If the first page has no content, stop fetching the next page.
   EXPECT_EQ(1, article_proto_->pages_size());
   VerifyArticleProtoMatchesMultipageData(
       article_proto_.get(), distiller_data.get(), 1, 1);
 }
 
 TEST_F(DistillerTest, DistillMultiplePagesSecondEmpty) {
   base::MessageLoopForUI loop;
   const size_t kNumPages = 8;
   std::unique_ptr<MultipageDistillerData> distiller_data =
@@ skipping 10 matching lines @@
   distiller_data->distilled_values.erase(
       distiller_data->distilled_values.begin() + empty_page_num);
   distiller_data->distilled_values.insert(
       distiller_data->distilled_values.begin() + empty_page_num,
       distilled_value.release());
 
   distiller_.reset(
       new DistillerImpl(url_fetcher_factory_, DomDistillerOptions()));
   DistillPage(distiller_data->page_urls[0],
               CreateMockDistillerPages(distiller_data.get(), kNumPages, 0));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   VerifyArticleProtoMatchesMultipageData(
       article_proto_.get(), distiller_data.get(), kNumPages, kNumPages);
 }
 
 TEST_F(DistillerTest, DistillPreviousPage) {
   base::MessageLoopForUI loop;
   const size_t kNumPages = 8;
 
   // The page number of the article on which distillation starts.
   int start_page_num = 3;
   std::unique_ptr<MultipageDistillerData> distiller_data =
       CreateMultipageDistillerDataWithoutImages(kNumPages);
 
   distiller_.reset(
       new DistillerImpl(url_fetcher_factory_, DomDistillerOptions()));
   DistillPage(distiller_data->page_urls[start_page_num],
               CreateMockDistillerPages(distiller_data.get(), kNumPages,
                                        start_page_num));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   VerifyArticleProtoMatchesMultipageData(
       article_proto_.get(), distiller_data.get(), kNumPages, kNumPages);
 }
 
 TEST_F(DistillerTest, IncrementalUpdates) {
   base::MessageLoopForUI loop;
   const size_t kNumPages = 8;
 
   // The page number of the article on which distillation starts.
   int start_page_num = 3;
   std::unique_ptr<MultipageDistillerData> distiller_data =
       CreateMultipageDistillerDataWithoutImages(kNumPages);
 
   distiller_.reset(
       new DistillerImpl(url_fetcher_factory_, DomDistillerOptions()));
   DistillPage(distiller_data->page_urls[start_page_num],
               CreateMockDistillerPages(distiller_data.get(), kNumPages,
                                        start_page_num));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kTitle, article_proto_->title());
   ASSERT_EQ(kNumPages, static_cast<size_t>(article_proto_->pages_size()));
   EXPECT_EQ(kNumPages, in_sequence_updates_.size());
 
   VerifyIncrementalUpdatesMatch(
       distiller_data.get(), kNumPages, in_sequence_updates_, start_page_num);
 }
 
 TEST_F(DistillerTest, IncrementalUpdatesDoNotDeleteFinalArticle) {
   base::MessageLoopForUI loop;
   const size_t kNumPages = 8;
   int start_page_num = 3;
   std::unique_ptr<MultipageDistillerData> distiller_data =
       CreateMultipageDistillerDataWithoutImages(kNumPages);
 
   distiller_.reset(
       new DistillerImpl(url_fetcher_factory_, DomDistillerOptions()));
   DistillPage(distiller_data->page_urls[start_page_num],
               CreateMockDistillerPages(distiller_data.get(), kNumPages,
                                        start_page_num));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kNumPages, in_sequence_updates_.size());
 
   in_sequence_updates_.clear();
 
   // Should still be able to access article and pages.
   VerifyArticleProtoMatchesMultipageData(
       article_proto_.get(), distiller_data.get(), kNumPages, kNumPages);
 }
 
 TEST_F(DistillerTest, DeletingArticleDoesNotInterfereWithUpdates) {
   base::MessageLoopForUI loop;
   const size_t kNumPages = 8;
   std::unique_ptr<MultipageDistillerData> distiller_data =
       CreateMultipageDistillerDataWithoutImages(kNumPages);
   // The page number of the article on which distillation starts.
   int start_page_num = 3;
 
   distiller_.reset(
       new DistillerImpl(url_fetcher_factory_, DomDistillerOptions()));
   DistillPage(distiller_data->page_urls[start_page_num],
               CreateMockDistillerPages(distiller_data.get(), kNumPages,
                                        start_page_num));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kNumPages, in_sequence_updates_.size());
   EXPECT_EQ(kTitle, article_proto_->title());
   ASSERT_EQ(kNumPages, static_cast<size_t>(article_proto_->pages_size()));
 
   // Delete the article.
   article_proto_.reset();
   VerifyIncrementalUpdatesMatch(
       distiller_data.get(), kNumPages, in_sequence_updates_, start_page_num);
 }
 
 TEST_F(DistillerTest, CancelWithDelayedImageFetchCallback) {
   base::MessageLoopForUI loop;
   vector<int> image_indices;
   image_indices.push_back(0);
   std::unique_ptr<base::Value> distilled_value =
       CreateDistilledValueReturnedFromJS(kTitle, kContent, image_indices, "");
   TestDistillerURLFetcher* delayed_fetcher = new TestDistillerURLFetcher(true);
   MockDistillerURLFetcherFactory mock_url_fetcher_factory;
   EXPECT_CALL(mock_url_fetcher_factory, CreateDistillerURLFetcher())
       .WillOnce(Return(delayed_fetcher));
   distiller_.reset(
       new DistillerImpl(mock_url_fetcher_factory, DomDistillerOptions()));
   DistillPage(kURL, CreateMockDistillerPage(distilled_value.get(), GURL(kURL)));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   // Post callback from the url fetcher and then delete the distiller.
   delayed_fetcher->PostCallbackTask();
   distiller_.reset();
 
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(DistillerTest, CancelWithDelayedJSCallback) {
   base::MessageLoopForUI loop;
   std::unique_ptr<base::Value> distilled_value =
       CreateDistilledValueReturnedFromJS(kTitle, kContent, vector<int>(), "");
   MockDistillerPage* distiller_page = NULL;
   distiller_.reset(
       new DistillerImpl(url_fetcher_factory_, DomDistillerOptions()));
   DistillPage(kURL,
               CreateMockDistillerPageWithPendingJSCallback(&distiller_page,
                                                            GURL(kURL)));
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   ASSERT_TRUE(distiller_page);
   // Post the task to execute javascript and then delete the distiller.
   distiller_page->OnDistillationDone(GURL(kURL), distilled_value.get());
   distiller_.reset();
 
-  base::MessageLoop::current()->RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace dom_distiller