src/content/renderer/manifest/manifest_manager.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/renderer/manifest/manifest_manager.h"
   6
   7 #include "base/bind.h"
   8 #include "base/strings/nullable_string16.h"
   9 #include "content/common/manifest_manager_messages.h"
  10 #include "content/public/renderer/render_frame.h"
  11 #include "content/renderer/fetchers/manifest_fetcher.h"
  12 #include "content/renderer/manifest/manifest_parser.h"
  13 #include "third_party/WebKit/public/platform/WebURLResponse.h"
  14 #include "third_party/WebKit/public/web/WebDocument.h"
  15 #include "third_party/WebKit/public/web/WebLocalFrame.h"
  16
  17 namespace content {
  18
  19 ManifestManager::ManifestManager(RenderFrame* render_frame)
  20     : RenderFrameObserver(render_frame),
  21       may_have_manifest_(false),
  22       manifest_dirty_(true) {
  23 }
  24
  25 ManifestManager::~ManifestManager() {
  26   if (fetcher_)
  27     fetcher_->Cancel();
  28
  29   // Consumers in the browser process will not receive this message but they
  30   // will be aware of the RenderFrame dying and should act on that. Consumers
  31   // in the renderer process should be correctly notified.
  32   ResolveCallbacks(ResolveStateFailure);
  33 }
  34
  35 bool ManifestManager::OnMessageReceived(const IPC::Message& message) {
  36   bool handled = true;
  37
  38   IPC_BEGIN_MESSAGE_MAP(ManifestManager, message)
  39     IPC_MESSAGE_HANDLER(ManifestManagerMsg_RequestManifest, OnRequestManifest)
  40     IPC_MESSAGE_UNHANDLED(handled = false)
  41   IPC_END_MESSAGE_MAP()
  42
  43   return handled;
  44 }
  45
  46 void ManifestManager::OnRequestManifest(int request_id) {
  47   GetManifest(base::Bind(&ManifestManager::OnRequestManifestComplete,
  48                          base::Unretained(this), request_id));
  49 }
  50
  51 void ManifestManager::OnRequestManifestComplete(
  52     int request_id, const Manifest& manifest) {
  53   // When sent via IPC, the Manifest must follow certain security rules.
  54   Manifest ipc_manifest = manifest;
  55   ipc_manifest.name = base::NullableString16(
  56       ipc_manifest.name.string().substr(0, Manifest::kMaxIPCStringLength),
  57       ipc_manifest.name.is_null());
  58   ipc_manifest.short_name = base::NullableString16(
  59         ipc_manifest.short_name.string().substr(0,
  60                                                 Manifest::kMaxIPCStringLength),
  61         ipc_manifest.short_name.is_null());
  62   for (size_t i = 0; i < ipc_manifest.icons.size(); ++i) {
  63     ipc_manifest.icons[i].type = base::NullableString16(
  64         ipc_manifest.icons[i].type.string().substr(
  65             0, Manifest::kMaxIPCStringLength),
  66         ipc_manifest.icons[i].type.is_null());
  67   }
  68
  69   Send(new ManifestManagerHostMsg_RequestManifestResponse(
  70       routing_id(), request_id, ipc_manifest));
  71 }
  72
  73 void ManifestManager::GetManifest(const GetManifestCallback& callback) {
  74   if (!may_have_manifest_) {
  75     callback.Run(Manifest());
  76     return;
  77   }
  78
  79   if (!manifest_dirty_) {
  80     callback.Run(manifest_);
  81     return;
  82   }
  83
  84   pending_callbacks_.push_back(callback);
  85
  86   // Just wait for the running call to be done if there are other callbacks.
  87   if (pending_callbacks_.size() > 1)
  88     return;
  89
  90   FetchManifest();
  91 }
  92
  93 void ManifestManager::DidChangeManifest() {
  94   may_have_manifest_ = true;
  95   manifest_dirty_ = true;
  96 }
  97
  98 void ManifestManager::FetchManifest() {
  99   GURL url(render_frame()->GetWebFrame()->document().manifestURL());
 100
 101   if (url.is_empty()) {
 102     ResolveCallbacks(ResolveStateFailure);
 103     return;
 104   }
 105
 106   fetcher_.reset(new ManifestFetcher(url));
 107
 108   // TODO(mlamouri,kenneth): this is not yet taking into account manifest-src
 109   // CSP rule, see http://crbug.com/409996.
 110   fetcher_->Start(render_frame()->GetWebFrame(),
 111                   base::Bind(&ManifestManager::OnManifestFetchComplete,
 112                              base::Unretained(this),
 113                              render_frame()->GetWebFrame()->document().url()));
 114 }
 115
 116 void ManifestManager::OnManifestFetchComplete(
 117     const GURL& document_url,
 118     const blink::WebURLResponse& response,
 119     const std::string& data) {
 120   if (response.isNull() && data.empty()) {
 121     ResolveCallbacks(ResolveStateFailure);
 122     return;
 123   }
 124
 125   manifest_ = ManifestParser::Parse(data, response.url(), document_url);
 126
 127   fetcher_.reset();
 128   ResolveCallbacks(ResolveStateSuccess);
 129 }
 130
 131 void ManifestManager::ResolveCallbacks(ResolveState state) {
 132   if (state == ResolveStateFailure)
 133     manifest_ = Manifest();
 134
 135   manifest_dirty_ = state != ResolveStateSuccess;
 136
 137   Manifest manifest = manifest_;
 138   std::list<GetManifestCallback> callbacks = pending_callbacks_;
 139
 140   pending_callbacks_.clear();
 141
 142   for (std::list<GetManifestCallback>::const_iterator it = callbacks.begin();
 143        it != callbacks.end(); ++it) {
 144     it->Run(manifest);
 145   }
 146 }
 147
 148 } // namespace content