src/xwalk/runtime/browser/android/intercepted_request_data_impl.cc

   1 // Copyright (c) 2012 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 "xwalk/runtime/browser/android/intercepted_request_data_impl.h"
   6
   7 #include <string>
   8
   9 #include "base/android/jni_android.h"
  10 #include "base/android/jni_string.h"
  11 #include "jni/InterceptedRequestData_jni.h"
  12 #include "net/url_request/url_request.h"
  13 #include "net/url_request/url_request_job.h"
  14 #include "xwalk/runtime/browser/android/net/android_protocol_handler.h"
  15 #include "xwalk/runtime/browser/android/net/android_stream_reader_url_request_job.h"
  16 #include "xwalk/runtime/browser/android/net/input_stream_impl.h"
  17 #include "xwalk/runtime/browser/xwalk_browser_context.h"
  18 #include "xwalk/runtime/browser/xwalk_runner.h"
  19
  20 using base::android::ScopedJavaLocalRef;
  21
  22 namespace xwalk {
  23
  24 namespace {
  25
  26 class StreamReaderJobDelegateImpl
  27     : public AndroidStreamReaderURLRequestJob::Delegate {
  28  public:
  29     StreamReaderJobDelegateImpl(
  30         const InterceptedRequestDataImpl* intercepted_request_data)
  31         : intercepted_request_data_impl_(intercepted_request_data) {
  32       DCHECK(intercepted_request_data_impl_);
  33     }
  34
  35     virtual scoped_ptr<InputStream> OpenInputStream(
  36         JNIEnv* env,
  37         const GURL& url) OVERRIDE {
  38       return intercepted_request_data_impl_->GetInputStream(env).Pass();
  39     }
  40
  41     virtual void OnInputStreamOpenFailed(net::URLRequest* request,
  42                                          bool* restart) OVERRIDE {
  43       *restart = false;
  44     }
  45
  46     virtual bool GetMimeType(JNIEnv* env,
  47                              net::URLRequest* request,
  48                              xwalk::InputStream* stream,
  49                              std::string* mime_type) OVERRIDE {
  50       return intercepted_request_data_impl_->GetMimeType(env, mime_type);
  51     }
  52
  53     virtual bool GetCharset(JNIEnv* env,
  54                             net::URLRequest* request,
  55                             xwalk::InputStream* stream,
  56                             std::string* charset) OVERRIDE {
  57       return intercepted_request_data_impl_->GetCharset(env, charset);
  58     }
  59
  60     virtual bool GetPackageName(JNIEnv* env,
  61                                 std::string* name) OVERRIDE {
  62       return intercepted_request_data_impl_->GetPackageName(env, name);
  63     }
  64
  65  private:
  66     const InterceptedRequestDataImpl* intercepted_request_data_impl_;
  67 };
  68
  69 }  // namespace
  70
  71 InterceptedRequestDataImpl::InterceptedRequestDataImpl(
  72     const base::android::JavaRef<jobject>& obj)
  73   : java_object_(obj) {
  74 }
  75
  76 InterceptedRequestDataImpl::~InterceptedRequestDataImpl() {
  77 }
  78
  79 scoped_ptr<InputStream>
  80 InterceptedRequestDataImpl::GetInputStream(JNIEnv* env) const {
  81   ScopedJavaLocalRef<jobject> jstream =
  82       Java_InterceptedRequestData_getData(env, java_object_.obj());
  83   if (jstream.is_null())
  84     return scoped_ptr<InputStream>();
  85   return make_scoped_ptr<InputStream>(new InputStreamImpl(jstream));
  86 }
  87
  88 bool InterceptedRequestDataImpl::GetMimeType(JNIEnv* env,
  89                                              std::string* mime_type) const {
  90   ScopedJavaLocalRef<jstring> jstring_mime_type =
  91       Java_InterceptedRequestData_getMimeType(env, java_object_.obj());
  92   if (jstring_mime_type.is_null())
  93     return false;
  94   *mime_type = ConvertJavaStringToUTF8(jstring_mime_type);
  95   return true;
  96 }
  97
  98 bool InterceptedRequestDataImpl::GetCharset(
  99     JNIEnv* env, std::string* charset) const {
 100   ScopedJavaLocalRef<jstring> jstring_charset =
 101       Java_InterceptedRequestData_getCharset(env, java_object_.obj());
 102   if (jstring_charset.is_null())
 103     return false;
 104   *charset = ConvertJavaStringToUTF8(jstring_charset);
 105   return true;
 106 }
 107
 108 bool InterceptedRequestDataImpl::GetPackageName(
 109     JNIEnv* env, std::string* name) const {
 110   // TODO(Xingnan): Implement this if we use intercepter for app scheme.
 111   return false;
 112 }
 113
 114 bool RegisterInterceptedRequestData(JNIEnv* env) {
 115   return RegisterNativesImpl(env);
 116 }
 117
 118 net::URLRequestJob* InterceptedRequestDataImpl::CreateJobFor(
 119     net::URLRequest* request,
 120     net::NetworkDelegate* network_delegate) const {
 121   scoped_ptr<AndroidStreamReaderURLRequestJob::Delegate>
 122       stream_reader_job_delegate_impl(new StreamReaderJobDelegateImpl(this));
 123
 124   XWalkBrowserContext* browser_context =
 125       XWalkRunner::GetInstance()->browser_context();
 126   std::string content_security_policy = browser_context->GetCSPString();
 127
 128   return new AndroidStreamReaderURLRequestJob(
 129       request, network_delegate, stream_reader_job_delegate_impl.Pass(),
 130       content_security_policy);
 131 }
 132
 133 }  // namespace xwalk