[WebView] Move files from native to browser

android_webview/browser/aw_contents_io_thread_client_impl.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_io_thread_client_impl.h"
+#include "android_webview/browser/aw_contents_io_thread_client_impl.h"
 
 #include <map>
 #include <memory>
 #include <utility>
 
+#include "android_webview/browser/aw_contents_background_thread_client.h"
+#include "android_webview/browser/aw_web_resource_response_impl.h"
 #include "android_webview/browser/net/aw_web_resource_request.h"
 #include "android_webview/common/devtools_instrumentation.h"
-#include "android_webview/native/aw_contents_background_thread_client.h"
-#include "android_webview/native/aw_web_resource_response_impl.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/android/jni_weak_ref.h"
 #include "base/lazy_instance.h"
 #include "base/synchronization/lock.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_request_info.h"
@@ skipping 71 matching lines @@
 RfhToIoThreadClientMap* RfhToIoThreadClientMap::GetInstance() {
   return g_instance_.Pointer();
 }
 
 void RfhToIoThreadClientMap::Set(pair<int, int> rfh_id,
                                  const IoThreadClientData& client) {
   base::AutoLock lock(map_lock_);
   rfh_to_io_thread_client_[rfh_id] = client;
 }
 
-bool RfhToIoThreadClientMap::Get(
-    pair<int, int> rfh_id, IoThreadClientData* client) {
+bool RfhToIoThreadClientMap::Get(pair<int, int> rfh_id,
+                                 IoThreadClientData* client) {
   base::AutoLock lock(map_lock_);
   RenderFrameHostToIoThreadClientType::iterator iterator =
       rfh_to_io_thread_client_.find(rfh_id);
   if (iterator == rfh_to_io_thread_client_.end())
     return false;
 
   *client = iterator->second;
   return true;
 }
 
@@ skipping 22 matching lines @@
 
 void RfhToIoThreadClientMap::Erase(int frame_tree_node_id) {
   base::AutoLock lock(map_lock_);
   frame_tree_node_to_io_thread_client_.erase(frame_tree_node_id);
 }
 
 // ClientMapEntryUpdater ------------------------------------------------------
 
 class ClientMapEntryUpdater : public content::WebContentsObserver {
  public:
-  ClientMapEntryUpdater(JNIEnv* env, WebContents* web_contents,
+  ClientMapEntryUpdater(JNIEnv* env,
+                        WebContents* web_contents,
                         jobject jdelegate);
 
   void RenderFrameCreated(RenderFrameHost* render_frame_host) override;
   void RenderFrameDeleted(RenderFrameHost* render_frame_host) override;
   void WebContentsDestroyed() override;
 
  private:
   JavaObjectWeakGlobalRef jdelegate_;
 };
 
 ClientMapEntryUpdater::ClientMapEntryUpdater(JNIEnv* env,
                                              WebContents* web_contents,
                                              jobject jdelegate)
-    : content::WebContentsObserver(web_contents),
-      jdelegate_(env, jdelegate) {
+    : content::WebContentsObserver(web_contents), jdelegate_(env, jdelegate) {
   DCHECK(web_contents);
   DCHECK(jdelegate);
 
   if (web_contents->GetMainFrame())
     RenderFrameCreated(web_contents->GetMainFrame());
 }
 
 void ClientMapEntryUpdater::RenderFrameCreated(RenderFrameHost* rfh) {
   IoThreadClientData client_data;
   client_data.io_thread_client = jdelegate_;
   client_data.pending_association = false;
   RfhToIoThreadClientMap::GetInstance()->Set(GetRenderFrameHostIdPair(rfh),
                                              client_data);
   RfhToIoThreadClientMap::GetInstance()->Set(rfh->GetFrameTreeNodeId(),
                                              client_data);
 }
 
 void ClientMapEntryUpdater::RenderFrameDeleted(RenderFrameHost* rfh) {
   RfhToIoThreadClientMap::GetInstance()->Erase(GetRenderFrameHostIdPair(rfh));
   RfhToIoThreadClientMap::GetInstance()->Erase(rfh->GetFrameTreeNodeId());
 }
 
 void ClientMapEntryUpdater::WebContentsDestroyed() {
   delete this;
 }
 
-} // namespace
+}  // namespace
 
 // AwContentsIoThreadClientImpl -----------------------------------------------
 
 // static
 std::unique_ptr<AwContentsIoThreadClient> AwContentsIoThreadClient::FromID(
     int render_process_id,
     int render_frame_id) {
   pair<int, int> rfh_id(render_process_id, render_frame_id);
   IoThreadClientData client_data;
   if (!RfhToIoThreadClientMap::GetInstance()->Get(rfh_id, &client_data))
@@ skipping 43 matching lines @@
 // static
 void AwContentsIoThreadClientImpl::RegisterPendingContents(
     WebContents* web_contents) {
   IoThreadClientData client_data;
   client_data.pending_association = true;
   RfhToIoThreadClientMap::GetInstance()->Set(
       GetRenderFrameHostIdPair(web_contents->GetMainFrame()), client_data);
 }
 
 // static
-void AwContentsIoThreadClientImpl::Associate(
-    WebContents* web_contents,
-    const JavaRef<jobject>& jclient) {
+void AwContentsIoThreadClientImpl::Associate(WebContents* web_contents,
+                                             const JavaRef<jobject>& jclient) {
   JNIEnv* env = AttachCurrentThread();
   // The ClientMapEntryUpdater lifespan is tied to the WebContents.
   new ClientMapEntryUpdater(env, web_contents, jclient.obj());
 }
 
 // static
 void AwContentsIoThreadClientImpl::SetServiceWorkerIoThreadClient(
     const base::android::JavaRef<jobject>& jclient,
     const base::android::JavaRef<jobject>& browser_context) {
   // TODO: currently there is only one browser context so it is ok to
@@ skipping 12 matching lines @@
   if (java_delegate.is_null())
     return std::unique_ptr<AwContentsIoThreadClient>();
 
   return std::unique_ptr<AwContentsIoThreadClient>(
       new AwContentsIoThreadClientImpl(false, java_delegate));
 }
 
 AwContentsIoThreadClientImpl::AwContentsIoThreadClientImpl(
     bool pending_association,
     const JavaRef<jobject>& obj)
-  : pending_association_(pending_association),
-    java_object_(obj) {
-}
+    : pending_association_(pending_association), java_object_(obj) {}
 
 AwContentsIoThreadClientImpl::~AwContentsIoThreadClientImpl() {
   // explict, out-of-line destructor.
 }
 
 bool AwContentsIoThreadClientImpl::PendingAssociation() const {
   return pending_association_;
 }
 
-AwContentsIoThreadClient::CacheMode
-AwContentsIoThreadClientImpl::GetCacheMode() const {
+AwContentsIoThreadClient::CacheMode AwContentsIoThreadClientImpl::GetCacheMode()
+    const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (java_object_.is_null())
     return AwContentsIoThreadClient::LOAD_DEFAULT;
 
   JNIEnv* env = AttachCurrentThread();
   return static_cast<AwContentsIoThreadClient::CacheMode>(
       Java_AwContentsIoThreadClient_getCacheMode(env, java_object_));
 }
 
-
 namespace {
 
 std::unique_ptr<AwWebResourceResponse> RunShouldInterceptRequest(
     const AwWebResourceRequest& request,
     JavaObjectWeakGlobalRef ref) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   JNIEnv* env = AttachCurrentThread();
   base::android::ScopedJavaLocalRef<jobject> obj = ref.get(env);
   if (obj.is_null())
     return nullptr;
@@ skipping 82 matching lines @@
 bool AwContentsIoThreadClientImpl::ShouldBlockNetworkLoads() const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (java_object_.is_null())
     return false;
 
   JNIEnv* env = AttachCurrentThread();
   return Java_AwContentsIoThreadClient_shouldBlockNetworkLoads(env,
                                                                java_object_);
 }
 
-} // namespace android_webview
+}  // namespace android_webview