Support for distilling prior pages in an article.

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 <map>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 26 matching lines @@
   const char* kImageData[kTotalImages] = {"abcde", "12345"};
 
   const string GetImageName(int page_num, int image_num) {
     return base::IntToString(page_num) + "_" + base::IntToString(image_num);
   }
 
   scoped_ptr<base::ListValue> CreateDistilledValueReturnedFromJS(
       const string& title,
       const string& content,
       const vector<int>& image_indices,
-      const string& next_page_url) {
+      const string& next_page_url,
+      const string& prev_page_url = "") {
     scoped_ptr<base::ListValue> list(new base::ListValue());
 
     list->AppendString(title);
     list->AppendString(content);
     list->AppendString(next_page_url);
+    list->AppendString(prev_page_url);
     for (size_t i = 0; i < image_indices.size(); ++i) {
       list->AppendString(kImageURLs[image_indices[i]]);
     }
     return list.Pass();
   }
 
 }  // namespace
 
 namespace dom_distiller {
 
@@ skipping 77 matching lines @@
   MockDistillerPage* distiller_page = new MockDistillerPage(delegate);
   EXPECT_CALL(*distiller_page, InitImpl());
   EXPECT_CALL(*distiller_page, LoadURLImpl(kurl))
       .WillOnce(testing::InvokeWithoutArgs(distiller_page,
                                            &DistillerPage::OnLoadURLDone));
   EXPECT_CALL(*distiller_page, ExecuteJavaScriptImpl(_)).WillOnce(
       DistillerPageOnExecuteJavaScriptDone(distiller_page, kurl, list));
   return distiller_page;
 }
 
-ACTION_P3(CreateMockDistillerPages, lists, kurls, num_pages) {
+ACTION_P4(CreateMockDistillerPages, lists, kurls, num_pages, start_page_num) {
   DistillerPage::Delegate* delegate = arg0;
   MockDistillerPage* distiller_page = new MockDistillerPage(delegate);
   EXPECT_CALL(*distiller_page, InitImpl());
   {
     testing::InSequence s;
+    // Distiller prefers distilling past pages first. E.g. when distillation
+    // starts on page 2 then pages are distilled in the order: 2, 1, 0, 3, 4.
+    vector<int> page_nums;
+    for (int page = start_page_num; page >= 0; --page)
+      page_nums.push_back(page);
+    for (int page = start_page_num + 1; page < num_pages; ++page)
+      page_nums.push_back(page);
 
-    for (int page = 0; page < num_pages; ++page) {
+    for (size_t page_num = 0; page_num < page_nums.size(); ++page_num) {
+      int page = page_nums[page_num];
       GURL url = GURL(kurls[page]);
       EXPECT_CALL(*distiller_page, LoadURLImpl(url))
           .WillOnce(testing::InvokeWithoutArgs(distiller_page,
                                                &DistillerPage::OnLoadURLDone));
       EXPECT_CALL(*distiller_page, ExecuteJavaScriptImpl(_))
           .WillOnce(DistillerPageOnExecuteJavaScriptDone(
               distiller_page, url, lists[page].get()));
     }
   }
   return distiller_page;
@@ skipping 70 matching lines @@
   for (int i = 0; i < kNumPages; ++i) {
     string next_page_url = "";
     if (i + 1 < kNumPages)
       next_page_url = page_urls[i + 1];
 
     list[i] = CreateDistilledValueReturnedFromJS(
         kTitle, content[i], image_indices[i], next_page_url);
   }
 
   EXPECT_CALL(page_factory_, CreateDistillerPageMock(_))
-      .WillOnce(CreateMockDistillerPages(list, page_urls, kNumPages));
+      .WillOnce(CreateMockDistillerPages(list, page_urls, kNumPages, 0));
 
   distiller_.reset(new DistillerImpl(page_factory_, url_fetcher_factory_));
   distiller_->Init();
   distiller_->DistillPage(
       GURL(page_urls[0]),
       base::Bind(&DistillerTest::OnDistillPageDone, base::Unretained(this)));
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(kTitle, article_proto_->title());
   EXPECT_EQ(article_proto_->pages_size(), kNumPages);
   for (int page_num = 0; page_num < kNumPages; ++page_num) {
@@ skipping 43 matching lines @@
   for (size_t page_num = 0; page_num < kMaxPagesInArticle; ++page_num) {
     page_urls[page_num] = url_prefix + base::IntToString(page_num + 1);
     string content = "Content for page:" + base::IntToString(page_num);
     string next_page_url = url_prefix + base::IntToString(page_num + 2);
     list[page_num] = CreateDistilledValueReturnedFromJS(
         kTitle, content, vector<int>(), next_page_url);
   }
 
   EXPECT_CALL(page_factory_, CreateDistillerPageMock(_))
       .WillOnce(CreateMockDistillerPages(
-          list, page_urls, static_cast<int>(kMaxPagesInArticle)));
+          list, page_urls, static_cast<int>(kMaxPagesInArticle), 0));
 
   distiller_.reset(new DistillerImpl(page_factory_, url_fetcher_factory_));
 
   distiller_->SetMaxNumPagesInArticle(kMaxPagesInArticle);
 
   distiller_->Init();
   distiller_->DistillPage(
       GURL(page_urls[0]),
       base::Bind(&DistillerTest::OnDistillPageDone, base::Unretained(this)));
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(kTitle, article_proto_->title());
   EXPECT_EQ(kMaxPagesInArticle,
             static_cast<size_t>(article_proto_->pages_size()));
 
   // Now check if distilling an article with exactly the page limit works by
   // resetting the next page url of the last page of the article.
   list[kMaxPagesInArticle - 1] =
       CreateDistilledValueReturnedFromJS(kTitle, "Content", vector<int>(), "");
   EXPECT_CALL(page_factory_, CreateDistillerPageMock(_))
       .WillOnce(CreateMockDistillerPages(
-          list, page_urls, static_cast<int>(kMaxPagesInArticle)));
+          list, page_urls, static_cast<int>(kMaxPagesInArticle), 0));
 
   distiller_.reset(new DistillerImpl(page_factory_, url_fetcher_factory_));
   distiller_->SetMaxNumPagesInArticle(kMaxPagesInArticle);
+
+  distiller_->Init();
+  distiller_->DistillPage(
+      GURL(page_urls[0]),
+      base::Bind(&DistillerTest::OnDistillPageDone, base::Unretained(this)));
+  base::MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(kTitle, article_proto_->title());
+  EXPECT_EQ(kMaxPagesInArticle,
+            static_cast<size_t>(article_proto_->pages_size()));
+
+  // Now check if distilling an article with exactly the page limit works by
+  // resetting the next page url of the last page of the article.
+  list[kMaxPagesInArticle - 1] =
+      CreateDistilledValueReturnedFromJS(kTitle, "Content", vector<int>(), "");
+  EXPECT_CALL(page_factory_, CreateDistillerPageMock(_))
+      .WillOnce(CreateMockDistillerPages(
+          list, page_urls, static_cast<int>(kMaxPagesInArticle), 0));
+
+  distiller_.reset(new DistillerImpl(page_factory_, url_fetcher_factory_));
+  distiller_->SetMaxNumPagesInArticle(kMaxPagesInArticle);
 
   distiller_->Init();
   distiller_->DistillPage(
       GURL(page_urls[0]),
       base::Bind(&DistillerTest::OnDistillPageDone, base::Unretained(this)));
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(kTitle, article_proto_->title());
   EXPECT_EQ(kMaxPagesInArticle,
             static_cast<size_t>(article_proto_->pages_size()));
 }
@@ skipping 31 matching lines @@
       distilled_values[page_num] = CreateDistilledValueReturnedFromJS(
           kTitle, content[page_num], vector<int>(), next_page_url);
     } else {
       distilled_values[page_num].reset(base::Value::CreateNullValue());
     }
   }
 
   // Expect only calls till the failed page number.
   EXPECT_CALL(page_factory_, CreateDistillerPageMock(_))
       .WillOnce(CreateMockDistillerPages(
-          distilled_values, page_urls, failed_page_num + 1));
+          distilled_values, page_urls, failed_page_num + 1, 0));
 
   distiller_.reset(new DistillerImpl(page_factory_, url_fetcher_factory_));
   distiller_->Init();
   distiller_->DistillPage(
       GURL(page_urls[0]),
       base::Bind(&DistillerTest::OnDistillPageDone, base::Unretained(this)));
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(kTitle, article_proto_->title());
   EXPECT_EQ(article_proto_->pages_size(), failed_page_num);
   for (int page_num = 0; page_num < failed_page_num; ++page_num) {
     const DistilledPageProto& page = article_proto_->pages(page_num);
     EXPECT_EQ(content[page_num], page.html());
     EXPECT_EQ(page_urls[page_num], page.url());
   }
 }
 
+TEST_F(DistillerTest, DistillPreviousPage) {
+  base::MessageLoopForUI loop;
+  const int kNumPages = 8;
+  string content[kNumPages];
+  string page_urls[kNumPages];
+  scoped_ptr<base::Value> distilled_values[kNumPages];
+
+  // The page number of the article on which distillation starts.
+  int start_page_number = 3;
+  string url_prefix = "http://a.com/";
+  for (int page_no = 0; page_no < kNumPages; ++page_no) {
+    page_urls[page_no] = url_prefix + base::IntToString(page_no);
+    content[page_no] = "Content for page:" + base::IntToString(page_no);
+    string next_page_url = (page_no + 1 < kNumPages)
+                               ? url_prefix + base::IntToString(page_no + 1)
+                               : "";
+    string prev_page_url = (page_no > 0) ? page_urls[page_no - 1] : "";
+    distilled_values[page_no] = CreateDistilledValueReturnedFromJS(
+        kTitle, content[page_no], vector<int>(), next_page_url, prev_page_url);
+  }
+
+  EXPECT_CALL(page_factory_, CreateDistillerPageMock(_))
+      .WillOnce(CreateMockDistillerPages(
+          distilled_values, page_urls, kNumPages, start_page_number));
+
+  distiller_.reset(new DistillerImpl(page_factory_, url_fetcher_factory_));
+  distiller_->Init();
+  distiller_->DistillPage(
+      GURL(page_urls[start_page_number]),
+      base::Bind(&DistillerTest::OnDistillPageDone, base::Unretained(this)));
+  base::MessageLoop::current()->RunUntilIdle();
+  EXPECT_EQ(kTitle, article_proto_->title());
+  EXPECT_EQ(kNumPages, article_proto_->pages_size());
+  for (int page_no = 0; page_no < kNumPages; ++page_no) {
+    const DistilledPageProto& page = article_proto_->pages(page_no);
+    EXPECT_EQ(content[page_no], page.html());
+    EXPECT_EQ(page_urls[page_no], page.url());
+  }
+}
+
 }  // namespace dom_distiller