Add WebView.saveWebArchive support to android_webview.

android_webview/native/aw_contents.cc

 // 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.
 
 #include "android_webview/native/aw_contents.h"
 
 #include "android_webview/browser/renderer_host/aw_render_view_host_ext.h"
 #include "android_webview/native/aw_browser_dependency_factory.h"
 #include "android_webview/native/aw_contents_container.h"
 #include "android_webview/native/aw_web_contents_delegate.h"
@@ skipping 81 matching lines @@
 // when the callback goes out of scope.
 void DocumentHasImagesCallback(ScopedJavaGlobalRef<jobject>* message,
                                bool has_images) {
   Java_AwContents_onDocumentHasImagesResponse(AttachCurrentThread(),
                                               has_images,
                                               message->obj());
 }
 }  // namespace
 
 void AwContents::DocumentHasImages(JNIEnv* env, jobject obj, jobject message) {
+  ScopedJavaGlobalRef<jobject>* j_message = new ScopedJavaGlobalRef<jobject>();

[benm (inactive), 2012/09/19 14:06:52]

did you mean to change this here?

[Ted C, 2012/09/19 16:53:22]

Yeah, when looking at refactoring the code below, I noticed that the
ScopedJavaLocalRef was there as a requirement for the constructor of the global
ref.  A few of us found it confusing so I thought I would be more explicit and
avoid creating it at all.  We already loose the local ref from message
automatically when we return from this method, so there was no need for the
scoped version.

+  j_message->Reset(env, message);
   render_view_host_ext_->DocumentHasImages(
-      base::Bind(&DocumentHasImagesCallback,
-                 base::Owned(new ScopedJavaGlobalRef<jobject>(
-                    ScopedJavaLocalRef<jobject>(env, message)))));
+      base::Bind(&DocumentHasImagesCallback, base::Owned(j_message)));
+}
+
+namespace {
+void GenerateMHTMLCallback(ScopedJavaGlobalRef<jobject>* callback,
+                           const FilePath& path, int64 size) {
+  JNIEnv* env = AttachCurrentThread();
+  // Android files are UTF8, so the path conversion below is safe.
+  Java_AwContents_generateMHTMLCallback(
+      env,
+      base::android::ConvertUTF8ToJavaString(env, path.AsUTF8Unsafe()).obj(),
+      size, callback->obj());
+}
+}  // namespace
+
+void AwContents::GenerateMHTML(JNIEnv* env, jobject obj,
+                               jstring jpath, jobject callback) {
+  ScopedJavaGlobalRef<jobject>* j_callback = new ScopedJavaGlobalRef<jobject>();
+  j_callback->Reset(env, callback);
+  contents_container_->GetWebContents()->GenerateMHTML(
+      FilePath(base::android::ConvertJavaStringToUTF8(env, jpath)),
+      base::Bind(&GenerateMHTMLCallback, base::Owned(j_callback)));
 }
 
 void AwContents::onReceivedHttpAuthRequest(
     const base::android::JavaRef<jobject>& handler,
     const std::string& host,
     const std::string& realm) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> jhost = ConvertUTF8ToJavaString(env, host);
   ScopedJavaLocalRef<jstring> jrealm = ConvertUTF8ToJavaString(env, realm);
   Java_AwContents_onReceivedHttpAuthRequest(env, java_ref_.get(env).obj(),
                                             handler.obj(), jhost.obj(),
                                             jrealm.obj());
 }
 
 static jint Init(JNIEnv* env,
                  jobject obj,
                  jobject web_contents_delegate,
                  jboolean private_browsing) {
   AwContents* tab = new AwContents(env, obj, web_contents_delegate,
                                    private_browsing);
   return reinterpret_cast<jint>(tab);
 }
 
 bool RegisterAwContents(JNIEnv* env) {
   return RegisterNativesImpl(env) >= 0;
 }
 
 
 }  // namespace android_webview