Implement offline mode behind a flag

content/browser/loader/offline_policy.h

+// Copyright (c) 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.
+
+#ifndef CONTENT_BROWSER_LOADER_OFFLINE_POLICY
+#define CONTENT_BROWSER_LOADER_OFFLINE_POLICY
+
+#include <map>
+
+#include "base/basictypes.h"
+#include "content/common/content_export.h"
+#include "webkit/glue/resource_type.h"

[droger_google, 2013/04/05 10:55:24]

This file should probably moved out of webkit/glue.
We don't want to introduce any new use of webkit/glue.

[Randy Smith (Not in Mondays), 2013/04/05 17:56:38]

Darin, what's your perspective on this?  I feel like I have no good sense of the
appropriate webkit/RDH relationship.

+
+struct ResourceHostMsg_Request;
+
+namespace net {
+class HttpResponseInfo;
+class URLRequest;
+}
+
+namespace content {
+
+// This class controls under what conditions resources will be fetched
+// from cache even if stale rather than from the network.  For example,
+// one policy would be that if requests for a particular route (e.g. "tab")
+// is unable to reach the server, other requests made with the same route
+// can be loaded from cache without first requiring a network timeout.
+class CONTENT_EXPORT OfflinePolicy {

[droger_google, 2013/04/05 10:55:24]

OfflinePolicy is in content/. This may not be a blocker for now, but if there is
another place to put this file it could be better for us.
We try not to use content/ on iOS.

[Randy Smith (Not in Mondays), 2013/04/05 17:56:38]

Wow, that's a stranger and more alien world than I thought :-}.  Can you give me
a quick sketch of what you do use on iOS and what the architectural relationship
is between Chrome for iOS and Chromium standard?  

There's not really any place *besides* content I can think of to put this, since
it needs to be accessible from the ResourceDispatcherHostImpl (which
specifically rules out chrome/) and it doesn't really have to do with the
network.   Do you have any thoughts about where it should go?

[blundell, 2013/04/08 16:52:04]

We're currently determining (with darin and jam) what the exact policy is going
to be re: Chrome for iOS's usage of content/. I'll bring up this example in
those discussions, and am also going to write up a design document explaining
Chrome for iOS's usage of content/ once the dust settles. In the meantime please
feel free to keep this in content/, and I or David will loop back around once we
have resolution on this issue.

On 2013/04/05 17:56:38, rdsmith wrote:

+ public:
+  OfflinePolicy();
+  ~OfflinePolicy();
+
+  // Return any additional load flags to be ORed for the current request.
+  int GetAdditionalLoadFlags(int child_id, int route_id, int current_flags,

[droger_google, 2013/04/05 10:55:24]

I have two issues with this API:

1) On iOS, we don't have the concept of route_id and child_id.
It seems that these are only used to generate a key (as a pair of int), so that
should be abstracted as a generic key.

2) This class seems to manage all Chrome connections (as it keeps a map of all
the route_id x child_id). This is not something that fits very well in our
architecture, as it would be more natural for us to have one OfflinePolicy per
tab. If we have only one instance of this for all the tabs, I don't really know
what can own it.

[Randy Smith (Not in Mondays), 2013/04/05 17:56:38]

My thought about using a single class was that it would make it easy for us to
play with policies that spanned tabs, e.g. the entire browser going online or
offline at once.  But we could also do that with static variables on a shared
class, so I don't think it's a very high priority preference.  And given that I
suspect the alternative is to suggest you use a global variable, a per-tab class
probably makes sense :-}.  And onn a implementation level, it's a pretty simple
refactor to hoist the child_id,route_id mapping up into
ResourceDispatcherHostImpl and making the class per-tab.  I'll do that and put
up a new patchset.

+                             ResourceType::Type resource_type);
+
+  // Incorporate online/offline information from a completed request.
+  void RequestCompleted(int child_id, int route_id,
+                        const net::HttpResponseInfo& response_info);
+
+  void RouteRemoved(int child_id, int route_id);
+
+private:
+  enum RouteOfflineState { ROUTE_INIT, ROUTE_ONLINE, ROUTE_OFFLINE };
+
+  // child_id, route_id -> state.
+  typedef std::map<std::pair<int, int>, RouteOfflineState> RouteMap;
+
+  RouteMap offline_state_map_;
+
+  DISALLOW_COPY_AND_ASSIGN(OfflinePolicy);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_LOADER_OFFLINE_POLICY