Seculative resource prefetching for URLs CL.

chrome/browser/predictors/resource_prefetch_predictor.h

+// Copyright (c) 2012 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_PREDICTORS_RESOURCE_PREFETCH_PREDICTOR_H_
+#define CHROME_BROWSER_PREDICTORS_RESOURCE_PREFETCH_PREDICTOR_H_
+#pragma once
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
+#include "base/time.h"
+#include "chrome/browser/predictors/resource_prefetch_common.h"
+#include "chrome/browser/predictors/resource_prefetch_predictor_tables.h"
+#include "chrome/browser/profiles/profile_keyed_service.h"
+#include "content/public/browser/notification_observer.h"
+#include "content/public/browser/notification_registrar.h"
+#include "googleurl/src/gurl.h"
+#include "webkit/glue/resource_type.h"
+
+class PredictorsHandler;
+class Profile;
+
+namespace content {
+class WebContents;
+}
+
+namespace history {
+class URLrowsDatabase;
+}
+
+namespace net {
+class URLRequest;
+}
+
+namespace predictors {
+
+// Contains logic for learning what can be prefetched and for kicking off
+// speculative prefetching.
+// - The class is a profile keyed service owned by the profile.
+// - All the non-static methods of this class need to be called on the UI
+//   thread.
+//
+// The overall flow of the resource prefetching algorithm is as follows:
+//
+// * ResourcePrefetchPredictorObserver - Listens for URL requests, responses and
+//   redirects on the IO thread(via RDHostDelegate) and post tasks to the
+//   ResourcePrefetchPredictor on the UI thread. This is owned by the
+//   ProfileIOData for the profile.
+// * ResourcePrefetchPredictorTables - Persists ResourcePrefetchPredictor data
+//   to a sql database. Runs entirely on the DB thread. Owned by the
+//   PredictorDatabase.
+// * ResourcePrefetchPredictor - Learns about resource requirements per URL in
+//   the UI thread through the ResourcePrefetchPredictorObserver and perisists
+//   it to disk in the DB thread through the ResourcePrefetchPredictorTables.
+//   Owned by profile.
+//
+// TODO(shishir): Implement the prefetching of resources.
+class ResourcePrefetchPredictor
+    : public ProfileKeyedService,
+      public content::NotificationObserver,
+      public base::SupportsWeakPtr<ResourcePrefetchPredictor> {
+ public:
+  explicit ResourcePrefetchPredictor(Profile* profile);
+  virtual ~ResourcePrefetchPredictor();
+
+  // Stores the data that we need to get from the URLRequest.
+  struct URLRequestSummary {
+    URLRequestSummary();
+    URLRequestSummary(const URLRequestSummary& other);
+    ~URLRequestSummary();
+    bool InitFromURLRequest(net::URLRequest* request, bool is_response);

[willchan no longer on Chromium, 2012/05/31 02:08:58]

Why is this defined here? It seems to only be used in the observer. How about
defining a local function in the observer's .cc file that handles this
initialization. I say this because structs aren't supposed to have behavior
according to the Google style guide.

[Shishir, 2012/06/02 01:19:29]

Done.

+
+    NavigationID navigation_id_;

[willchan no longer on Chromium, 2012/05/31 02:08:58]

Remove the trailing underscores for structs.

[Shishir, 2012/06/02 01:19:29]

Done.

+    GURL resource_url_;
+    ResourceType::Type resource_type_;
+
+    // Only for responses.
+    std::string mime_type_;
+    bool was_cached_;
+  };
+
+  // Thread safe.
+  static bool IsEnabled();
+  static bool ShouldRecordRequest(net::URLRequest* request,
+                                  ResourceType::Type resource_type);
+  static bool ShouldRecordResponse(net::URLRequest* response);
+  static bool ShouldRecordRedirect(net::URLRequest* response);
+
+  // UI thread.

[willchan no longer on Chromium, 2012/05/31 02:08:58]

Everything's on the IO thread, right? Other than the statics. I'd remove this
comment so people don't go looking for IO thread methods.

[Shishir, 2012/06/02 01:19:29]

Done.

+  void RecordURLRequest(const URLRequestSummary& request);
+  void RecordUrlResponse(const URLRequestSummary& response);
+  void RecordUrlRedirect(const URLRequestSummary& response);
+
+ private:
+  friend class ::PredictorsHandler;

[willchan no longer on Chromium, 2012/05/31 02:08:58]

Hm...do you really need this? AFAICT, this is only for UrlTableCacheMap. Why
don't you add a const member function that returns a const reference to that
guy? I guess it's a bit annoying to expose some structs and typedefs, but
whatever. I think it's cleaner than friend declarations. Up to you guys though,
since it's style preference and your guys' code.

[Shishir, 2012/06/02 01:19:29]

In the following CLs, we will be exposing much more data in the chrome:// page
and it makes more sense to have this as a friend rather than to expose each
underlying object.

+
+  // TODO(shishir): Maybe use pointers to make the sort cheaper.
+  typedef ResourcePrefetchPredictorTables::UrlTableRow UrlTableRow;
+  typedef std::vector<UrlTableRow> UrlTableRowVector;
+
+  struct UrlTableCacheValue {
+    UrlTableRowVector rows_;
+    base::Time last_visit_;
+  };
+
+  typedef std::map<NavigationID, std::vector<URLRequestSummary> > NavigationMap;
+  typedef std::map<GURL, UrlTableCacheValue> UrlTableCacheMap;
+
+  // content::NotificationObserver methods OVERRIDE.
+  virtual void Observe(int type,
+                       const content::NotificationSource& source,
+                       const content::NotificationDetails& details) OVERRIDE;
+
+  static bool IsHandledMainPage(net::URLRequest* request);
+  static bool IsHandledSubresource(net::URLRequest* response);
+  static bool IsCacheable(const net::URLRequest* response);
+
+  // Deal with different kinds of requests.
+  void OnMainFrameRequest(const URLRequestSummary& request);
+  void OnMainFrameResponse(const URLRequestSummary& response);
+  void OnMainFrameRedirect(const URLRequestSummary& response);
+  void OnSubresourceResponse(const URLRequestSummary& response);
+  void OnSubresourceLoadedFromMemory(const NavigationID& navigation_id,
+                                     const GURL& resource_url);
+
+  void LazilyInitialize();
+  void OnHistoryAndCacheLoaded();
+  void CreateCaches(std::vector<UrlTableRow>* url_rows);
+  bool ShouldTrackUrl(const GURL& url);
+  void CleanupAbandonedNavigations(const NavigationID& navigation_id);
+  void OnNavigationComplete(const NavigationID& navigation_id);
+  void LearnUrlNavigation(const GURL& main_frame_url,
+                          const std::vector<URLRequestSummary>& new_value);
+  void RemoveAnEntryFromUrlDB();
+  void MaybeReportAccuracyStats(const NavigationID& navigation_id);
+
+  enum InitializationState {

[willchan no longer on Chromium, 2012/05/31 02:08:58]

types go in the beginning of the access section, per style guide

[Shishir, 2012/06/02 01:19:29]

Done.

+    NOT_INITIALIZED = 0,
+    INITIALIZING = 1,
+    INITIALIZED = 2
+  };
+
+  Profile* profile_;

[willchan no longer on Chromium, 2012/05/31 02:08:58]

Profile* const? Should never change, right?

[Shishir, 2012/06/02 01:19:29]

Done.

+  InitializationState initialization_state_;
+  scoped_refptr<ResourcePrefetchPredictorTables> tables_;

[willchan no longer on Chromium, 2012/05/31 02:08:58]

Doesn't this class own the ResourcePrefetchPredictorTables? I think this
situation is pretty similar to ResourcePrefetchPredictorObserver. I think what
you want to do is allocate the object here and use PostTaskAndReply() (you're
already doing this) with a WeakPtr to |this|, and then in the destructor of
ResourcePrefetchPredictor, post the deletion of the
ResourcePrefetchPredictorTables object to the DB thread. That will provide more
well-defined ownership semantics.

[Shishir, 2012/06/02 01:19:29]

I would like to defer this to another CL since this touches files not in this
CL. Adding a todo in predictor_database.h for this. Will send out a CL for it
once this one goes in.

+  scoped_ptr<content::NotificationRegistrar> notification_registrar_;
+
+  NavigationMap inflight_navigations_;
+  UrlTableCacheMap url_table_cache_;
+
+  DISALLOW_COPY_AND_ASSIGN(ResourcePrefetchPredictor);
+};
+
+}  // namespace predictors
+
+#endif  // CHROME_BROWSER_PREDICTORS_RESOURCE_PREFETCH_PREDICTOR_H_