Initial commit of the blimp/ folder and target

blimp/client/compositor/blimp_context_provider.h

 // Copyright 2015 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.
 
-#ifndef ANDROID_WEBVIEW_BROWSER_AW_RENDER_THREAD_CONTEXT_PROVIDER_H_
-#define ANDROID_WEBVIEW_BROWSER_AW_RENDER_THREAD_CONTEXT_PROVIDER_H_
+#ifndef BLIMP_CLIENT_COMPOSITOR_BLIMP_CONTEXT_PROVIDER_H_
+#define BLIMP_CLIENT_COMPOSITOR_BLIMP_CONTEXT_PROVIDER_H_
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_checker.h"
 #include "cc/output/context_provider.h"
-#include "gpu/command_buffer/service/in_process_command_buffer.h"
+#include "gpu/command_buffer/client/gl_in_process_context.h"
 #include "skia/ext/refptr.h"
+#include "ui/gl/gl_surface.h"
+#include "ui/gl/gl_surface.h"
 
-namespace gfx {
-class GLSurface;
-}
+namespace blimp {
 
-namespace gpu {
-class GLInProcessContext;
-}
+// Helper class to provide a graphics context for the compositor.
+class BlimpContextProvider : public cc::ContextProvider {
+ public:
+  static scoped_refptr<BlimpContextProvider> Create(

[Wez, 2015/08/27 18:23:55]

Did I mention "oh no, ref-counting?!? so sad" yet? So sad. ;(

[danakj, 2015/08/27 18:27:31]

Sorry :(

The context provider can be held onto by the user of it after the context is
lost until it receives a new context provider. This avoids a whole lot of
plumbing ownerships around and lets the context factories make a new context in
their callback about the context being lost rather than round-tripping through
whoever has a context and making them also have "i dont have a context"
potentially doubling the number of states in their code.

+      gfx::AcceleratedWidget widget);
 
-namespace android_webview {
+  void OnLostContext();

[Wez, 2015/08/27 18:23:55]

Who calls this, and why? What effect does it have?

[David Trainor- moved to gerrit, 2015/08/28 01:23:47]

Made it private.  It's part of the flow for handling lost GL contexts (required
by the interfaces).  Basically we plumb this call through from
GLInProcessContext to the callback specified by ContextProvider::SetLostCallback
and clean up our internal state.

I'll don't know all of the internal details, but I'll take a look.

 
-class AwRenderThreadContextProvider : public cc::ContextProvider {
- public:
-  static scoped_refptr<AwRenderThreadContextProvider> Create(
-      scoped_refptr<gfx::GLSurface> surface,
-      scoped_refptr<gpu::InProcessCommandBuffer::Service> service);
-
- private:
-  AwRenderThreadContextProvider(
-      scoped_refptr<gfx::GLSurface> surface,
-      scoped_refptr<gpu::InProcessCommandBuffer::Service> service);
-  ~AwRenderThreadContextProvider() override;
-
-  // cc::ContextProvider:
+  // cc::ContextProvider -------------------------------------------------------

[Wez, 2015/08/27 18:23:55]

See elsewhere re my nit-picky views on comment style.

[David Trainor- moved to gerrit, 2015/08/28 01:23:47]

Done.

   bool BindToCurrentThread() override;
+  void DetachFromThread() override;
   Capabilities ContextCapabilities() override;
   gpu::gles2::GLES2Interface* ContextGL() override;
   gpu::ContextSupport* ContextSupport() override;
   class GrContext* GrContext() override;
   void InvalidateGrContext(uint32_t state) override;
   void SetupLock() override;
   base::Lock* GetLock() override;
   void VerifyContexts() override;
   void DeleteCachedResources() override;
   bool DestroyedOnMainThread() override;
   void SetLostContextCallback(
       const LostContextCallback& lost_context_callback) override;
   void SetMemoryPolicyChangedCallback(
       const MemoryPolicyChangedCallback& memory_policy_changed_callback)
       override;
 
-  void OnLostContext();
+ protected:
+  explicit BlimpContextProvider(gfx::AcceleratedWidget widget);
+  ~BlimpContextProvider() override;
 
+ private:
   base::ThreadChecker main_thread_checker_;
+  base::ThreadChecker context_thread_checker_;
 
   scoped_ptr<gpu::GLInProcessContext> context_;
   skia::RefPtr<class GrContext> gr_context_;
 
   cc::ContextProvider::Capabilities capabilities_;
 
   LostContextCallback lost_context_callback_;
 
+  base::Lock destroyed_lock_;
   bool destroyed_;
 
   base::Lock context_lock_;

[Wez, 2015/08/27 18:23:55]

Why is the context lock not grouped w/ the context?

[David Trainor- moved to gerrit, 2015/08/28 01:23:47]

It's only ever used by the cc::ContextProvider interface (not by this class). 
destroyed_lock_ is directly used with destroyed_ in this class, which is why
those were grouped.  Grouping it closer makes sense though :).

 
-  DISALLOW_COPY_AND_ASSIGN(AwRenderThreadContextProvider);
+  DISALLOW_COPY_AND_ASSIGN(BlimpContextProvider);
 };
 
-}  // namespace android_webview
+}  // namespace blimp
 
-#endif  // ANDROID_WEBVIEW_BROWSER_AW_RENDER_THREAD_CONTEXT_PROVIDER_H_
+#endif  // BLIMP_CLIENT_COMPOSITOR_BLIMP_CONTEXT_PROVIDER_H_