Simplify FakeGpuProcess* video accelerator tests

ui/ozone/public/ozone_gpu_test_helper.cc

 // Copyright 2014 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 "ui/ozone/public/ozone_gpu_test_helper.h"
 
+#include "base/synchronization/waitable_event.h"
 #include "base/thread_task_runner_handle.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_sender.h"
 #include "ipc/message_filter.h"
 #include "ui/ozone/public/gpu_platform_support.h"
 #include "ui/ozone/public/gpu_platform_support_host.h"
 #include "ui/ozone/public/ozone_platform.h"
 
 namespace ui {
@@ skipping 42 matching lines @@
 
   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
   base::WeakPtrFactory<FakeGpuProcess> weak_factory_;
 };
 
 class FakeGpuProcessHost {
  public:
   FakeGpuProcessHost(
       const scoped_refptr<base::SingleThreadTaskRunner>& gpu_task_runner)
       : gpu_task_runner_(gpu_task_runner), weak_factory_(this) {}
-  ~FakeGpuProcessHost() {}
+  ~FakeGpuProcessHost() {
+    base::WaitableEvent done(false, false);
+    gpu_task_runner_->PostTask(FROM_HERE,
+                               base::Bind(&FakeGpuProcessHost::Destroy,
+                                          weak_factory_.GetWeakPtr(), &done));
+    done.Wait();
+  }
 
   void Init() {
     base::Callback<void(IPC::Message*)> sender =
         base::Bind(&FakeGpuProcessHost::DispatchToGpuPlatformSupportTask,
                    weak_factory_.GetWeakPtr());
 
     ui::OzonePlatform::GetInstance()
         ->GetGpuPlatformSupportHost()
         ->OnChannelEstablished(kGpuProcessHostId, gpu_task_runner_, sender);

[dnicoara, 2015/03/17 18:15:16]

Grr, this is where the actual issue is. Can't use a weak_ptr on multiple
threads.

Off the top of my head I want to say that the DispatchToGpuPlatformSupport*()
methods could just be static functions. 

Perhaps that's enough, though one thing that worries me is that 
OnChannelDestroyed() is never called when the FakeGpuProcess* objects go away.
Perhaps that will be needed as well.

[vignatti (out of this project), 2015/03/17 18:59:05]

oh, I thought this snip was correct?

 
hmm I think we can call OnChannelDestroyed at ~FakeGpuProcess but I don't think
for the video tests there are observers or handlers installed at the moment. So
there wouldn't be any effect on doing this.

[dnicoara, 2015/03/17 21:28:56]

No, this is actually where this is very very wrong. The |sender| is going to be
called on the |gpu_task_runner_|. Since it is created on the main thread, the
weak_ptr is only guaranteed to work correctly on the main thread.
I don't think it would matter for the video tests either. Just wanted to point
it out in case there are other issues.

[vignatti (out of this project), 2015/03/18 15:38:29]

I actually think that the way you used weak_ptr here is fine for the purpose
wanted:

https://code.google.com/p/chromium/codesearch#chromium/src/base/memory/weak_p...

i.e., we bound weak_ptr to be used solely through |gpu_task_runner_|, so there's
no problem with that. We don't use that in the main thread. Or am I missing
something?

[dnicoara, 2015/03/18 17:19:28]

You're right, I'm getting confused by the code :(

Though we still can't do this by posting a task to invalidate the weak ptrs and
wait since |gpu_task_runner == ui_task_runner| should be supported.

I'm tempted to say we might need another object to act as the sender and take
the weak_ptr to that. Then in the dtor we could post a task with
DeletePointer(...). spang@ what do you think?

   }
 
  private:
+  void Destroy(base::WaitableEvent* done) {
+    DCHECK(gpu_task_runner_->BelongsToCurrentThread());
+    this->weak_factory_.InvalidateWeakPtrs();
+    done->Signal();
+  }
+
   void DispatchToGpuPlatformSupportTask(IPC::Message* msg) {
     ui::OzonePlatform::GetInstance()
         ->GetGpuPlatformSupport()
         ->OnMessageReceived(*msg);
     delete msg;
   }
 
   scoped_refptr<base::SingleThreadTaskRunner> gpu_task_runner_;
   base::WeakPtrFactory<FakeGpuProcessHost> weak_factory_;
 };
@@ skipping 18 matching lines @@
                             base::Unretained(fake_gpu_process_.get())));
   fake_gpu_process_->Init();
 
   fake_gpu_process_host_.reset(new FakeGpuProcessHost(gpu_task_runner));
   fake_gpu_process_host_->Init();
 
   return true;
 }
 
 }  // namespace ui