Factor out ContentViewAndroidDelegate

device/power_save_blocker/power_save_blocker_android.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 "device/power_save_blocker/power_save_blocker.h"
 
 #include "base/android/jni_android.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
@@ skipping 16 matching lines @@
   void RemoveBlock();
 
  private:
   friend class base::RefCountedThreadSafe<Delegate>;
   ~Delegate();
 
   base::WeakPtr<ui::ViewAndroid> view_android_;
 
   base::android::ScopedJavaGlobalRef<jobject> java_power_save_blocker_;
 
+  base::android::ScopedJavaGlobalRef<jobject> anchor_view_;
+
   scoped_refptr<base::SequencedTaskRunner> ui_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(Delegate);
 };
 
 PowerSaveBlocker::Delegate::Delegate(
     base::WeakPtr<ui::ViewAndroid> view_android,
     scoped_refptr<base::SequencedTaskRunner> ui_task_runner)
     : view_android_(view_android), ui_task_runner_(ui_task_runner) {
   JNIEnv* env = AttachCurrentThread();
   java_power_save_blocker_.Reset(Java_PowerSaveBlocker_create(env));
 }
 
 PowerSaveBlocker::Delegate::~Delegate() {}
 
 void PowerSaveBlocker::Delegate::ApplyBlock() {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
 
   ScopedJavaLocalRef<jobject> obj(java_power_save_blocker_);
   JNIEnv* env = AttachCurrentThread();
   if (view_android_) {
-    Java_PowerSaveBlocker_applyBlock(
-        env, obj.obj(), view_android_->GetViewAndroidDelegate().obj());
+    anchor_view_.Reset(view_android_->AcquireAnchorView());
+    Java_PowerSaveBlocker_applyBlock(env, obj.obj(), anchor_view_.obj());
   }
 }
 
 void PowerSaveBlocker::Delegate::RemoveBlock() {
   DCHECK(ui_task_runner_->RunsTasksOnCurrentThread());
   ScopedJavaLocalRef<jobject> obj(java_power_save_blocker_);
   JNIEnv* env = AttachCurrentThread();
   if (view_android_) {

[no sievers, 2016/07/14 23:14:32]

Here we also have to figure out how to not leak it.

WebContents owns WakeLockServiceContext which owns the PowerSaveBlocker.
So I'm not sure why we care about WebContentsDestroyed in WakeLockServiceContext
(besides having to think about the exact destruction order between CVC , which
is a WebContents::UserData for the ViewAndroid and the WakeLockServiceContext). 

[Jinsuk Kim, 2016/07/15 05:46:26]

Added RemoveAnchorView/Reset()

[no sievers, 2016/07/15 18:35:00]

The problem here is this:
if (view_android_) {
}

So we might still leak it if !view_android_.
That's why I was thinking maybe the scoped object that holds a ref to the
delegate an can *always* remove the View might be simpler than having to clean
up the destruction order and lifetime here for the wake locks. (The use of
WeakPtr here was probably just a lazy fix.)

[Jinsuk Kim, 2016/07/18 06:45:46]

Now I got it. Added ScopedAnchorView to remove the view regardless of
|ViewAndroid|

-    Java_PowerSaveBlocker_removeBlock(
-        env, obj.obj(), view_android_->GetViewAndroidDelegate().obj());
+    Java_PowerSaveBlocker_removeBlock(env, obj.obj());
+    view_android_->RemoveAnchorView(anchor_view_.obj());
   }
 }
 
 PowerSaveBlocker::PowerSaveBlocker(
     PowerSaveBlockerType type,
     Reason reason,
     const std::string& description,
     scoped_refptr<base::SequencedTaskRunner> ui_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> blocking_task_runner)
     : ui_task_runner_(ui_task_runner),
@@ skipping 16 matching lines @@
 
   delegate_ = new Delegate(view_android, ui_task_runner_);
   delegate_->ApplyBlock();
 }
 
 bool RegisterPowerSaveBlocker(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace device