[WebView] Move files from native to browser

android_webview/browser/aw_contents.cc

 // Copyright 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/aw_contents.h"
 
 #include <limits>
 #include <utility>
 
+#include "android_webview/browser/aw_autofill_client.h"
 #include "android_webview/browser/aw_browser_context.h"
 #include "android_webview/browser/aw_browser_main_parts.h"
+#include "android_webview/browser/aw_contents_client_bridge.h"
+#include "android_webview/browser/aw_contents_io_thread_client_impl.h"
+#include "android_webview/browser/aw_contents_lifecycle_notifier.h"
+#include "android_webview/browser/aw_gl_functor.h"
+#include "android_webview/browser/aw_pdf_exporter.h"
+#include "android_webview/browser/aw_picture.h"
+#include "android_webview/browser/aw_renderer_priority_manager.h"
 #include "android_webview/browser/aw_resource_context.h"
+#include "android_webview/browser/aw_web_contents_delegate.h"
 #include "android_webview/browser/browser_view_renderer.h"
 #include "android_webview/browser/child_frame.h"
 #include "android_webview/browser/deferred_gpu_command_service.h"
+#include "android_webview/browser/java_browser_view_renderer_helper.h"
 #include "android_webview/browser/net_disk_cache_remover.h"
+#include "android_webview/browser/permission/aw_permission_request.h"
+#include "android_webview/browser/permission/permission_request_handler.h"
+#include "android_webview/browser/permission/simple_permission_request.h"
 #include "android_webview/browser/render_thread_manager.h"
 #include "android_webview/browser/renderer_host/aw_resource_dispatcher_host_delegate.h"
 #include "android_webview/browser/scoped_app_gl_state_restore.h"
+#include "android_webview/browser/state_serializer.h"
 #include "android_webview/common/aw_hit_test_data.h"
 #include "android_webview/common/aw_switches.h"
 #include "android_webview/common/devtools_instrumentation.h"
-#include "android_webview/native/aw_autofill_client.h"
-#include "android_webview/native/aw_contents_client_bridge.h"
-#include "android_webview/native/aw_contents_io_thread_client_impl.h"
-#include "android_webview/native/aw_contents_lifecycle_notifier.h"
-#include "android_webview/native/aw_gl_functor.h"
-#include "android_webview/native/aw_pdf_exporter.h"
-#include "android_webview/native/aw_picture.h"
-#include "android_webview/native/aw_renderer_priority_manager.h"
-#include "android_webview/native/aw_web_contents_delegate.h"
-#include "android_webview/native/java_browser_view_renderer_helper.h"
-#include "android_webview/native/permission/aw_permission_request.h"
-#include "android_webview/native/permission/permission_request_handler.h"
-#include "android_webview/native/permission/simple_permission_request.h"
-#include "android_webview/native/state_serializer.h"
 #include "android_webview/public/browser/draw_gl.h"
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/android/locale_utils.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/atomicops.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 92 matching lines @@
 // static
 AwContents* AwContents::FromWebContents(WebContents* web_contents) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   return AwContentsUserData::GetContents(web_contents);
 }
 
 // static
 AwContents* AwContents::FromID(int render_process_id, int render_view_id) {
   content::RenderViewHost* rvh =
       content::RenderViewHost::FromID(render_process_id, render_view_id);
-  if (!rvh) return NULL;
+  if (!rvh)
+    return NULL;
   content::WebContents* web_contents =
       content::WebContents::FromRenderViewHost(rvh);
-  if (!web_contents) return NULL;
+  if (!web_contents)
+    return NULL;
   return FromWebContents(web_contents);
 }
 
 // static
 void UpdateDefaultLocale(JNIEnv* env,
                          const JavaParamRef<jclass>&,
                          const JavaParamRef<jstring>& locale,
                          const JavaParamRef<jstring>& locale_list) {
   g_locale = ConvertJavaStringToUTF8(env, locale);
   g_locale_list = ConvertJavaStringToUTF8(env, locale_list);
 }
 
 // static
 std::string AwContents::GetLocale() {
   return g_locale;
 }
 
 // static
 std::string AwContents::GetLocaleList() {
   return g_locale_list;
 }
 
 // static
 AwBrowserPermissionRequestDelegate* AwBrowserPermissionRequestDelegate::FromID(
-    int render_process_id, int render_frame_id) {
-  AwContents* aw_contents = AwContents::FromWebContents(
-      content::WebContents::FromRenderFrameHost(
+    int render_process_id,
+    int render_frame_id) {
+  AwContents* aw_contents =
+      AwContents::FromWebContents(content::WebContents::FromRenderFrameHost(
           content::RenderFrameHost::FromID(render_process_id,
                                            render_frame_id)));
   return aw_contents;
 }
 
 // static
 AwSafeBrowsingUIManager::UIManagerClient*
 AwSafeBrowsingUIManager::UIManagerClient::FromWebContents(
     WebContents* web_contents) {
   return AwContents::FromWebContents(web_contents);
@@ skipping 86 matching lines @@
                                                             render_frame_id);
   }
 }
 
 void AwContents::SetSaveFormData(bool enabled) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   InitAutofillIfNecessary(enabled);
   // We need to check for the existence, since autofill_manager_delegate
   // may not be created when the setting is false.
   if (AwAutofillClient::FromWebContents(web_contents_.get())) {
-    AwAutofillClient::FromWebContents(web_contents_.get())->
-        SetSaveFormData(enabled);
+    AwAutofillClient::FromWebContents(web_contents_.get())
+        ->SetSaveFormData(enabled);
   }
 }
 
 void AwContents::InitAutofillIfNecessary(bool enabled) {
   // Do not initialize if the feature is not enabled.
   if (!enabled)
     return;
   // Check if the autofill driver factory already exists.
   content::WebContents* web_contents = web_contents_.get();
   if (ContentAutofillDriverFactory::FromWebContents(web_contents))
@@ skipping 146 matching lines @@
   base::FilePath target_path(ConvertJavaStringToUTF8(env, jpath));
   web_contents_->GenerateMHTML(
       content::MHTMLGenerationParams(target_path),
       base::Bind(&GenerateMHTMLCallback,
                  ScopedJavaGlobalRef<jobject>(env, callback), target_path));
 }
 
 void AwContents::CreatePdfExporter(JNIEnv* env,
                                    const JavaParamRef<jobject>& obj,
                                    const JavaParamRef<jobject>& pdfExporter) {
-  pdf_exporter_.reset(
-      new AwPdfExporter(env,
-                        pdfExporter,
-                        web_contents_.get()));
+  pdf_exporter_.reset(new AwPdfExporter(env, pdfExporter, web_contents_.get()));
 }
 
 bool AwContents::OnReceivedHttpAuthRequest(const JavaRef<jobject>& handler,
                                            const std::string& host,
                                            const std::string& realm) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return false;
@@ skipping 10 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   browser_view_renderer_.SetOffscreenPreRaster(enabled);
 }
 
 void AwContents::AddVisitedLinks(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
     const JavaParamRef<jobjectArray>& jvisited_links) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   std::vector<base::string16> visited_link_strings;
-  base::android::AppendJavaStringArrayToStringVector(
-      env, jvisited_links, &visited_link_strings);
+  base::android::AppendJavaStringArrayToStringVector(env, jvisited_links,
+                                                     &visited_link_strings);
 
   std::vector<GURL> visited_link_gurls;
   std::vector<base::string16>::const_iterator itr;
   for (itr = visited_link_strings.begin(); itr != visited_link_strings.end();
        ++itr) {
     visited_link_gurls.push_back(GURL(*itr));
   }
 
   AwBrowserContext::FromWebContents(web_contents_.get())
       ->AddVisitedURLs(visited_link_gurls);
@@ skipping 16 matching lines @@
         "onGeolocationPermissionsShowPrompt");
     Java_AwContents_onGeolocationPermissionsShowPrompt(env, j_ref, j_origin);
   }
 }
 
 void ShowGeolocationPromptHelper(const JavaObjectWeakGlobalRef& java_ref,
                                  const GURL& origin) {
   JNIEnv* env = AttachCurrentThread();
   if (java_ref.get(env).obj()) {
     content::BrowserThread::PostTask(
-        content::BrowserThread::UI,
-        FROM_HERE,
-        base::Bind(&ShowGeolocationPromptHelperTask,
-                   java_ref,
-                   origin));
+        content::BrowserThread::UI, FROM_HERE,
+        base::Bind(&ShowGeolocationPromptHelperTask, java_ref, origin));
   }
 }
 
-} // anonymous namespace
+}  // anonymous namespace
 
 void AwContents::ShowGeolocationPrompt(const GURL& requesting_frame,
                                        base::Callback<void(bool)> callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   GURL origin = requesting_frame.GetOrigin();
   bool show_prompt = pending_geolocation_prompts_.empty();
   pending_geolocation_prompts_.push_back(OriginCallback(origin, callback));
   if (show_prompt) {
     ShowGeolocationPromptHelper(java_ref_, origin);
@@ skipping 40 matching lines @@
   if (removed_current_outstanding_callback) {
     JNIEnv* env = AttachCurrentThread();
     ScopedJavaLocalRef<jobject> j_ref = java_ref_.get(env);
     if (j_ref.obj()) {
       devtools_instrumentation::ScopedEmbedderCallbackTask embedder_callback(
           "onGeolocationPermissionsHidePrompt");
       Java_AwContents_onGeolocationPermissionsHidePrompt(env, j_ref);
     }
     if (!pending_geolocation_prompts_.empty()) {
       ShowGeolocationPromptHelper(java_ref_,
-                            pending_geolocation_prompts_.front().first);
+                                  pending_geolocation_prompts_.front().first);
     }
   }
 }
 
 void AwContents::OnPermissionRequest(
     base::android::ScopedJavaLocalRef<jobject> j_request,
     AwPermissionRequest* request) {
   DCHECK(!j_request.is_null());
   DCHECK(request);
 
@@ skipping 60 matching lines @@
 void AwContents::CancelGeolocationPermissionRequests(const GURL& origin) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
 
   if (Java_AwContents_useLegacyGeolocationPermissionAPI(env, obj)) {
     HideGeolocationPrompt(origin);
     return;
   }
-  permission_request_handler_->CancelRequest(
-      origin, AwPermissionRequest::Geolocation);
+  permission_request_handler_->CancelRequest(origin,
+                                             AwPermissionRequest::Geolocation);
 }
 
 void AwContents::RequestMIDISysexPermission(
     const GURL& origin,
     const base::Callback<void(bool)>& callback) {
   permission_request_handler_->SendRequest(
       std::unique_ptr<AwPermissionRequestDelegate>(new SimplePermissionRequest(
           origin, AwPermissionRequest::MIDISysex, callback)));
 }
 
@@ skipping 138 matching lines @@
                                          jfloat touch_major) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   gfx::PointF touch_center(x, y);
   gfx::SizeF touch_area(touch_major, touch_major);
   render_view_host_ext_->RequestNewHitTestDataAt(touch_center, touch_area);
 }
 
 void AwContents::UpdateLastHitTestData(JNIEnv* env,
                                        const JavaParamRef<jobject>& obj) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  if (!render_view_host_ext_->HasNewHitTestData()) return;
+  if (!render_view_host_ext_->HasNewHitTestData())
+    return;
 
   const AwHitTestData& data = render_view_host_ext_->GetLastHitTestData();
   render_view_host_ext_->MarkHitTestDataRead();
 
   // Make sure to null the Java object if data is empty/invalid.
   ScopedJavaLocalRef<jstring> extra_data_for_type;
   if (data.extra_data_for_type.length())
-    extra_data_for_type = ConvertUTF8ToJavaString(
-        env, data.extra_data_for_type);
+    extra_data_for_type =
+        ConvertUTF8ToJavaString(env, data.extra_data_for_type);
 
   ScopedJavaLocalRef<jstring> href;
   if (data.href.length())
     href = ConvertUTF16ToJavaString(env, data.href);
 
   ScopedJavaLocalRef<jstring> anchor_text;
   if (data.anchor_text.length())
     anchor_text = ConvertUTF16ToJavaString(env, data.anchor_text);
 
   ScopedJavaLocalRef<jstring> img_src;
@@ skipping 315 matching lines @@
 }
 
 namespace {
 void InvokeVisualStateCallback(const JavaObjectWeakGlobalRef& java_ref,
                                jlong request_id,
                                const JavaRef<jobject>& callback,
                                bool result) {
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref.get(env);
   if (obj.is_null())
-     return;
+    return;
   Java_AwContents_invokeVisualStateCallback(env, obj, callback, request_id);
 }
 }  // namespace
 
 void AwContents::InsertVisualStateCallback(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
     jlong request_id,
     const JavaParamRef<jobject>& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ skipping 97 matching lines @@
 
 void AwContents::SetExtraHeadersForUrl(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
     const JavaParamRef<jstring>& url,
     const JavaParamRef<jstring>& jextra_headers) {
   std::string extra_headers;
   if (jextra_headers)
     extra_headers = ConvertJavaStringToUTF8(env, jextra_headers);
   AwResourceContext* resource_context = static_cast<AwResourceContext*>(
-      AwBrowserContext::FromWebContents(web_contents_.get())->
-      GetResourceContext());
+      AwBrowserContext::FromWebContents(web_contents_.get())
+          ->GetResourceContext());
   resource_context->SetExtraHeaders(GURL(ConvertJavaStringToUTF8(env, url)),
                                     extra_headers);
 }
 
 void AwContents::SetJsOnlineProperty(JNIEnv* env,
                                      const JavaParamRef<jobject>& obj,
                                      jboolean network_up) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   render_view_host_ext_->SetJsOnlineProperty(network_up);
 }
@@ skipping 26 matching lines @@
 
 // TODO(sgurun) add support for posting a frame whose name is known (only
 //               main frame is supported at this time, see crbug.com/389721)
 void AwContents::PostMessageToFrame(JNIEnv* env,
                                     const JavaParamRef<jobject>& obj,
                                     const JavaParamRef<jstring>& frame_name,
                                     const JavaParamRef<jstring>& message,
                                     const JavaParamRef<jstring>& target_origin,
                                     const JavaParamRef<jobjectArray>& ports) {
   // Use an empty source origin for android webview.
-  content::MessagePortProvider::PostMessageToFrame(web_contents_.get(),
-                                                   env,
-                                                   nullptr,
-                                                   target_origin,
-                                                   message,
-                                                   ports);
+  content::MessagePortProvider::PostMessageToFrame(
+      web_contents_.get(), env, nullptr, target_origin, message, ports);
 }
 
 void AwContents::GrantFileSchemeAccesstoChildProcess(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj) {
   content::ChildProcessSecurityPolicy::GetInstance()->GrantScheme(
       web_contents_->GetRenderProcessHost()->GetID(), url::kFileScheme);
 }
 
 void AwContents::ResumeLoadingCreatedPopupWebContents(
@@ skipping 70 matching lines @@
 void AwContents::OnRenderProcessGone(int child_process_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return;
 
   Java_AwContents_onRenderProcessGone(env, obj, child_process_id);
 }
 
-bool AwContents::OnRenderProcessGoneDetail(int child_process_id,
-                                           bool crashed) {
+bool AwContents::OnRenderProcessGoneDetail(int child_process_id, bool crashed) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jobject> obj = java_ref_.get(env);
   if (obj.is_null())
     return false;
 
-  return Java_AwContents_onRenderProcessGoneDetail(env, obj,
-      child_process_id, crashed);
+  return Java_AwContents_onRenderProcessGoneDetail(env, obj, child_process_id,
+                                                   crashed);
 }
 
 void AwContents::RenderProcessReady(content::RenderProcessHost* host) {
   UpdateRendererPriority();
 }
 
 }  // namespace android_webview