add option for original domain

src/com/dom_distiller/client/PagingLinksFinder.java

 // Copyright 2014 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.
 
 /*
  * Parts of this file are adapted from Readability.
  *
  * Readability is Copyright (c) 2010 Src90 Inc
  * and licenced under the Apache License, Version 2.0.
  */
@@ skipping 32 matching lines @@
     private static final String NEXT_LINK_REGEX = "(next|weiter|continue|>([^\\|]|$)|»([^\\|]|$))";
     private static final String PREV_LINK_REGEX = "(prev|early|old|new|<|«)";
     private static final String POSITIVE_REGEX = "article|body|content|entry|hentry|main|page|pagination|post|text|blog|story";
     private static final String NEGATIVE_REGEX = "combx|comment|com-|contact|foot|footer|footnote|masthead|media|meta|outbrain|promo|related|scroll|shoutbox|sidebar|sponsor|shopping|tags|tool|widget";
     private static final String EXTRANEOUS_REGEX =
             "print|archive|comment|discuss|e[\\-]?mail|share|reply|all|login|sign|single";
     // Examples that match PAGE_NUMBER_REGEX are: "_p3", "-pg3", "p3", "_1", "-12-2".
     // Examples that don't match PAGE_NUMBER_REGEX are: "_p3 ", "p", "p123".
     private static final String PAGE_NUMBER_REGEX = "((_|-)?p[a-z]*|(_|-))[0-9]{1,2}$";
 
-    public static DomDistillerProtos.PaginationInfo getPaginationInfo() {
+    public static DomDistillerProtos.PaginationInfo getPaginationInfo(String original_domain) {
         DomDistillerProtos.PaginationInfo info = DomDistillerProtos.PaginationInfo.create();
-        String next = findNext(Document.get().getDocumentElement());
+        String next = findNext(Document.get().getDocumentElement(), original_domain);
         if (next != null) {
             info.setNextPage(next);
         }
         return info;
     }
 
-    public static String findNext(Element root) {
     /**
+     * @param original_domain The original domain of the page being processed if it's a file://.
      * @return The next page link for the document.
      */
-        return findPagingLink(root, PageLink.NEXT);
+    public static String findNext(Element root, String original_domain) {
+        return findPagingLink(root, original_domain, PageLink.NEXT);
     }
 
-    public static String findPrevious(Element root) {
     /**
+     * @param original_domain The original domain of the page being processed if it's a file://.
      * @return The previous page link for the document.
      */
-        return findPagingLink(root, PageLink.PREV);
+    public static String findPrevious(Element root, String original_domain) {
+        return findPagingLink(root, original_domain, PageLink.PREV);
     }
 
-    private static String findPagingLink(Element root, PageLink pageLink) {
+    private static String findPagingLink(Element root, String original_domain, PageLink pageLink) {
         // findPagingLink() is static, so clear mLinkDebugInfo before processing the links.
         if (LogUtil.isLoggable(LogUtil.DEBUG_LEVEL_PAGING_INFO)) {
             mLinkDebugInfo.clear();
         }
 
-        String baseUrl = findBaseUrl();
+        String baseUrl = findBaseUrl(original_domain);
         // Remove trailing '/' from window location href, because it'll be used to compare with
         // other href's whose trailing '/' are also removed.
         String wndLocationHref = StringUtil.findAndReplace(Window.Location.getHref(), "\\/$", "");
         NodeList<Element> allLinks = root.getElementsByTagName("A");
         Map<String, PagingLinkObj> possiblePages = new HashMap<String, PagingLinkObj>();
 
         // Loop through all links, looking for hints that they may be next- or previous- page links.
         // Things like having "page" in their textContent, className or id, or being a child of a
         // node with a page-y className or id.
         // Also possible: levenshtein distance? longest common subsequence?
@@ skipping 28 matching lines @@
                     linkHref.equalsIgnoreCase(wndLocationHref) ||
                     (pageLink == PageLink.NEXT && linkHref.equalsIgnoreCase(baseUrl))) {
                 appendDbgStrForLink(link,
                         "ignored: empty or same as current or base url" + baseUrl);
                 continue;
             }
 
             // If it's on a different domain, skip it.
             String[] urlSlashes = StringUtil.split(linkHref, "\\/+");
             if (urlSlashes.length < 3 ||  // Expect at least the protocol, domain, and path.
-                    !Window.Location.getHost().equalsIgnoreCase(urlSlashes[1])) {
+                    !getLocationHost(original_domain).equalsIgnoreCase(urlSlashes[1])) {
                 appendDbgStrForLink(link, "ignored: different domain");
                 continue;
             }
 
             // Use javascript innerText (instead of javascript textContent) to only get visible
             // text.
             String linkText = DomUtil.getInnerText(link);
 
             // If the linkText looks like it's not the next or previous page, skip it.
             if (StringUtil.match(linkText, EXTRANEOUS_REGEX) || linkText.length() > 25) {
@@ skipping 163 matching lines @@
                     topPage.mScore + ", txt=[" + topPage.mLinkText + "], " + pagingHref);
         }
 
         if (LogUtil.isLoggable(LogUtil.DEBUG_LEVEL_PAGING_INFO)) {
             logDbgInfoToConsole(pageLink, pagingHref, allLinks);
         }
 
         return pagingHref;
     }
 
-    private static String findBaseUrl() {
+    private static String getLocationHost(String original_domain) {
+        return original_domain.isEmpty() ? Window.Location.getHost() : original_domain;
+    }
+
+    private static String findBaseUrl(String original_domain) {
         // This extracts relevant parts from the window location's path based on various heuristics
         // to determine the path of the base URL of the document.  This path is then appended to the
         // window location protocol and host to form the base URL of the document.  This base URL is
         // then used as reference for comparison against an anchor's href to to determine if the
         // anchor is a next or previous paging link.
 
         // First, from the window's location's path, extract the segments delimited by '/'.  Then,
         // because the later segments probably contain less relevant information for the base URL,
         // reverse the segments for easier processing.
         // Note: '?' is a special character in RegEx, so enclose it within [] to specify the actual
@@ skipping 39 matching lines @@
             // If the first or second segment is shorter than 3 characters, and the first
             // segment was purely alphas, ignore it.
             if (i < 2 && segment.length() < 3 && !StringUtil.match(urlSlashes[0], "[a-z]")) {
                 continue;
             }
 
             // If we got here, append the segment to cleanedSegments.
             cleanedSegments.add(segment);
         }  // for all urlSlashes
 
-        return Window.Location.getProtocol() + "//" + Window.Location.getHost() + "/" +
+        return Window.Location.getProtocol() + "//" + getLocationHost(original_domain) + "/" +
                 reverseJoin(cleanedSegments, "/");
     }
 
     private static String reverseJoin(List<String> array, String delim) {
         // As per http://stackoverflow.com/questions/5748044/gwt-string-concatenation-operator-vs-stringbuffer,
         // + operator is faster for javascript than StringBuffer/StringBuilder.
         String joined = "";
         for (int i = array.size() - 1; i >= 0; i--) {
             joined += array.get(i);
             if (i > 0) joined += delim;
@@ skipping 63 matching lines @@
     }
 
     private enum PageLink {
         NEXT,
         PREV,
     }
 
     private static final Map<Element, String> mLinkDebugInfo = new HashMap<Element, String>();
 
 }