Serve offline page for online URL on disconnected or bad networks

chrome/browser/android/offline_pages/offline_page_request_handler.h

 // 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.
 
 #ifndef CHROME_BROWSER_ANDROID_OFFLINE_PAGES_OFFLINE_PAGE_REQUEST_HANDLER_H_
 #define CHROME_BROWSER_ANDROID_OFFLINE_PAGES_OFFLINE_PAGE_REQUEST_HANDLER_H_
 
 #include "base/macros.h"
+#include "base/memory/weak_ptr.h"
 #include "base/supports_user_data.h"
+#include "chrome/browser/android/offline_pages/offline_page_request_job.h"
+#include "content/public/browser/resource_request_info.h"
 #include "content/public/common/resource_type.h"
 
 namespace net {
 class NetworkDelegate;
 class URLRequest;
 class URLRequestInterceptor;
 class URLRequestJob;
 }
 
 namespace offline_pages {
 
+// This enum is used to tell current network state that will affect offline
+// page loading.
+enum class NetworkState {
+  // No network connection.
+  DISCONNECTED_NETWORK,
+  // Prohibitively slow means that the NetworkQualityEstimator reported a
+  // connection slow enough to warrant showing an offline page if available.
+  PROHIBITIVELY_SLOW_NETWORK,
+  // Network error received due to bad network, i.e. connected to a hotspot or
+  // proxy that does not have a working network.
+  FLAKY_NETWORK,
+  // Network is in working condition.
+  CONNECTED_NETWORK,
+  // Network condition check will be skipped. This will force to load the
+  // offline page if it is available.
+  SKIPPED_NETWORK_CHECK
+};
+
+// This enum is used for UMA reporting. It contains all possible outcomes of
+// handling requests that might service offline page in different network
+// conditions. Generally one of these outcomes will happen.
+// The fringe errors (like no OfflinePageModel, etc.) are not reported due
+// to their low probability.
+// NOTE: because this is used for UMA reporting, these values should not be
+// changed or reused; new values should be ended immediately before the MAX
+// value. Make sure to update the histogram enum
+// (OfflinePagesAggregatedRequestResult in histograms.xml) accordingly.
+// Public for testing.
+enum class AggregatedRequestResult {
+  SHOW_OFFLINE_ON_DISCONNECTED_NETWORK,
+  PAGE_NOT_FOUND_ON_DISCONNECTED_NETWORK,
+  SHOW_OFFLINE_ON_FLAKY_NETWORK,
+  PAGE_NOT_FOUND_ON_FLAKY_NETWORK,
+  SHOW_OFFLINE_ON_PROHIBITIVELY_SLOW_NETWORK,
+  PAGE_NOT_FOUND_ON_PROHIBITIVELY_SLOW_NETWORK,
+  PAGE_NOT_FRESH_ON_PROHIBITIVELY_SLOW_NETWORK,
+  SHOW_OFFLINE_ON_CONNECTED_NETWORK,
+  PAGE_NOT_FOUND_ON_CONNECTED_NETWORK,
+  NO_TAB_ID,
+  NO_WEB_CONTENTS,
+  SHOW_NET_ERROR_PAGE,
+  AGGREGATED_REQUEST_RESULT_MAX,

[fgorski, 2016/08/15 21:38:32]

nit: add a comment that new values are added above this point.

[jianli, 2016/08/15 23:15:43]

Such comment is already added at line 48.

+};
+
+// Header that indicates that the offline page should be loaded if it exists
+// regardless current network conditions. Its value is a comma/space separated
+// name-value pair that may provide reason or define custom behavior.
+extern const char kLoadingOfflinePageHeader[];
+
+// The name used in name-value pair of kLoadingOfflinePageHeader to denote the
+// reason for loading offline page.
+extern const char kLoadingOfflinePageReason[];
+// Possible values in name-value pair that denote the reason for loading offline
+// page.
+extern const char kLoadingOfflinePageDueToNetError[];
+
 // Class for servicing requests based on their offline information. Created one
 // per URLRequest and attached to each request.
 //
 // For each supported profile, OfflinePageRequestHandler::CreateInterceptor
 // should be called once to install the custom interceptor.
 //
 // For each request:
 // 1) When a request is starting, OfflinePageRequestHandler::InitializeHandler
 //    will be called to create a new handler and attach to the request.
 // 2) When a request is being processed, MaybeInterceptRequest of custom
 //    interceptor will be inquired.
 //    2.1) If the attached OfflinePageRequestHandler for the request is found,
 //         delegate to OfflinePageRequestHandler::MaybeCreateJob to do the work.
 //         2.1.1) Do immediate checks for those scenarios that the interception
 //                is not needed. Bail out if so.
 //         2.1.2) Start an async task to try to find the offline page.
 //         2.1.3) Return a custom URLRequestJob that is put on hold to wait
 //                for the result of finding offline page.
 //    2.2) Otherwise, bail out without interception.
-class OfflinePageRequestHandler : public base::SupportsUserData::Data {
+class OfflinePageRequestHandler : public base::SupportsUserData::Data,
+                                  public OfflinePageRequestJob::Delegate {
  public:
   // Attaches a newly created handler if the given |request| needs to
   // be handled by offline pages.
   static void InitializeHandler(net::URLRequest* request,
                                 content::ResourceType resource_type);
 
   // Returns the handler attached to |request|. This may return null if no
   // handler is attached.
   static OfflinePageRequestHandler* GetHandler(net::URLRequest* request);
 
   // Creates a protocol interceptor for offline pages. Created one per
   // supported, i.e. non-incognito, profile.
   // |profile_id|, which identifies the profile, is passed as a void* to ensure
   // it's not accidently used on the IO thread.
   static std::unique_ptr<net::URLRequestInterceptor> CreateInterceptor(
       void* profile_id);
 
+  static void ReportAggregatedRequestResult(AggregatedRequestResult result);
+
   ~OfflinePageRequestHandler() override;
 
+  // OfflinePageRequestJob::Delegate overrides:
+  void OnPrepareToRestart() override;
+
   net::URLRequestJob* MaybeCreateJob(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate,
       void* profile_id);
 
  private:
-  OfflinePageRequestHandler();
+  explicit OfflinePageRequestHandler(NetworkState network_state);
+
+  // Invoked from UI thread.
+  void GetOfflineFileURL(
+      const GURL& online_url,
+      void* profile_id,
+      content::ResourceRequestInfo::WebContentsGetter web_contents_getter);
+  void FailedToGetOfflineFileURL();
+
+  base::WeakPtr<OfflinePageRequestJob> offline_job_;
+
+  // True if the next time this request is started, the request should be
+  // serviced from the default handler.
+  bool use_default_ = false;
+
+  NetworkState network_state_;
+
+  base::WeakPtrFactory<OfflinePageRequestHandler> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(OfflinePageRequestHandler);
 };
 
 }  // namespace offline_pages
 
 #endif // CHROME_BROWSER_ANDROID_OFFLINE_PAGES_OFFLINE_PAGE_REQUEST_HANDLER_H_