Make sure that Content Handled application can be connected multiple times.

examples/png_viewer/png_viewer.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 <algorithm>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_tokenizer.h"
@@ skipping 13 matching lines @@
 #include "mojo/services/public/cpp/view_manager/view_manager_client_factory.h"
 #include "mojo/services/public/cpp/view_manager/view_manager_delegate.h"
 #include "mojo/services/public/cpp/view_manager/view_observer.h"
 #include "mojo/services/public/interfaces/content_handler/content_handler.mojom.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/codec/png_codec.h"
 
 namespace mojo {
 namespace examples {
 
+namespace {
+
+class EmbedderData {
+ public:
+  EmbedderData(Shell* shell, View* root) : bitmap_uploader_(root) {
+    bitmap_uploader_.Init(shell);
+    bitmap_uploader_.SetColor(SK_ColorGRAY);
+  }
+
+  BitmapUploader& bitmap_uploader() { return bitmap_uploader_; }
+
+ private:
+  BitmapUploader bitmap_uploader_;
+
+  DISALLOW_COPY_AND_ASSIGN(EmbedderData);
+};
+
+}  // namespace
+
 // TODO(aa): Hook up ZoomableMedia interface again.
 class PNGView : public ApplicationDelegate,
                 public ViewManagerDelegate,
                 public ViewObserver {
  public:
   PNGView(URLResponsePtr response)
       : width_(0),
         height_(0),
         app_(nullptr),
-        root_(nullptr),
         zoom_percentage_(kDefaultZoomPercentage) {
     DecodePNG(response.Pass());
   }
 
   virtual ~PNGView() {
-    if (root_)
-      root_->RemoveObserver(this);
+    for (auto& roots : embedder_for_roots_) {
+      roots.first->RemoveObserver(this);
+      delete roots.second;
+    }
   }
 
  private:
   static const uint16_t kMaxZoomPercentage = 400;
   static const uint16_t kMinZoomPercentage = 20;
   static const uint16_t kDefaultZoomPercentage = 100;
   static const uint16_t kZoomStep = 20;
 
   // Overridden from ApplicationDelegate:
   virtual void Initialize(ApplicationImpl* app) override {
     app_ = app;
     view_manager_client_factory_.reset(
         new ViewManagerClientFactory(app->shell(), this));
   }
 
   // Overridden from ApplicationDelegate:
   virtual bool ConfigureIncomingConnection(
       ApplicationConnection* connection) override {
     connection->AddService(view_manager_client_factory_.get());
     return true;
   }
 
   // Overridden from ViewManagerDelegate:
   virtual void OnEmbed(ViewManager* view_manager,
                        View* root,
                        ServiceProviderImpl* exported_services,
                        scoped_ptr<ServiceProvider> imported_services) override {
     // TODO(qsr): The same view should be embeddable on multiple views.
-    DCHECK(!root_);
-    root_ = root;
-    root_->AddObserver(this);
-    bitmap_uploader_.reset(new BitmapUploader(root_));
-    bitmap_uploader_->Init(app_->shell());
-    bitmap_uploader_->SetColor(SK_ColorGRAY);
-    if (bitmap_.get())
-      DrawBitmap();
+    DCHECK(embedder_for_roots_.find(root) == embedder_for_roots_.end());
+    root->AddObserver(this);
+    EmbedderData* embedder_data = new EmbedderData(app_->shell(), root);
+    embedder_for_roots_[root] = embedder_data;
+    embedder_data->bitmap_uploader().SetBitmap(
+        width_, height_,
+        make_scoped_ptr(new std::vector<unsigned char>(*bitmap_)),
+        BitmapUploader::BGRA);
   }
 
   virtual void OnViewManagerDisconnected(ViewManager* view_manager) override {
     // TODO(aa): Need to figure out how shutdown works.

[Aaron Boodman, 2014/11/19 15:58:15]

Can you remove this comment? Or move it to OnViewDestroyed()?

[qsr, 2014/11/19 16:37:21]

Done.

   }
 
   // Overridden from ViewObserver:
   virtual void OnViewBoundsChanged(View* view,
                                    const Rect& old_bounds,
                                    const Rect& new_bounds) override {
-    DCHECK_EQ(view, root_);
-    DrawBitmap();
+    DCHECK(embedder_for_roots_.find(view) != embedder_for_roots_.end());
   }
 
   virtual void OnViewDestroyed(View* view) override {
-    DCHECK_EQ(view, root_);
-    // TODO(qsr): It should not be necessary to cleanup the uploader, but it
-    // crashes if the GL context goes away.
-    bitmap_uploader_.reset();
-    ApplicationImpl::Terminate();
-  }
-
-  void DrawBitmap() {
-    if (!root_)
-      return;
-
-    bitmap_uploader_->SetBitmap(
-        width_, height_, bitmap_.Pass(), BitmapUploader::BGRA);
+    const auto& it = embedder_for_roots_.find(view);
+    DCHECK(it != embedder_for_roots_.end());
+    delete it->second;
+    embedder_for_roots_.erase(it);
+    if (embedder_for_roots_.size() == 0)
+      ApplicationImpl::Terminate();

[Aaron Boodman, 2014/11/18 23:46:15]

Out of scope for this CL, but I don't think this is the right time to shut down
the app.

[qsr, 2014/11/19 13:42:37]

 Can you elaborate? I can always change it in a next CL, but I'm not sure to
understand why, do you prefer to do this in OnViewManagerDisconnected? Never?

[Aaron Boodman, 2014/11/19 15:58:15]

This depends on the order you receive OnEmbed() and OnViewDestroyed(). That
seems pretty brittle to rely upon.

I think if you wanted something like this you could listen to
OnViewManagerDisconnected(). Because once that happens you know that you cannot
receive any more messages from the view manager.

But in general, this doesn't seem like the right way to shut down mojo apps. How
do you know that some other service is not doing something? Or won't begin doing
something shortly?

[qsr, 2014/11/19 16:37:21]

 Hum... I really hope I can count on receiving OnEmbed before receiving
OnViewDestroyed for the same view, otherwise, this cannot work at all... And if
this work, then I do not understand why this is brittle. I'm clearly missing
something.
 Hum... Then I probably also need to keep track of connected app by keeping
track of ServiceProvider. Again, if you do not mind, I'll let that for another
CL?

[Aaron Boodman, 2014/11/20 00:59:01]

No what I mean is that, during navigation for example, you might receive:

Embed(v1)
Embed(v2)
Destroy(v1)
Destroy(v2)

Or you might receive:

Embed(v1)
Destroy(v1)
Embed(v2)
Destroy(v2)

Both are reasonable orders for the VM to dispatch these messages in, depending
on implementation details.

But in the second example, you will shut down the app before Embed(v2) happens.
I think it would be better if apps did not depend on the order of these
events...
What I meant to convey is that shutdown is going to be a much larger problem
than this one CL or this one app. We should probably not write any shut down
code until we have a unified plan for how it's going to work for all apps. It's
just more code getting in the way.

Anyway this was already here before your CL, so you can just leave it.

   }
 
   void ZoomIn() {
+    // TODO(qsr,aa) Zoom should be per embedder view.
     if (zoom_percentage_ >= kMaxZoomPercentage)
       return;
     zoom_percentage_ += kZoomStep;
-    DrawBitmap();
   }
 
   void ZoomOut() {
     if (zoom_percentage_ <= kMinZoomPercentage)
       return;
     zoom_percentage_ -= kZoomStep;
-    DrawBitmap();
   }
 
   void ZoomToActualSize() {
     if (zoom_percentage_ == kDefaultZoomPercentage)
       return;
     zoom_percentage_ = kDefaultZoomPercentage;
-    DrawBitmap();
   }
 
   void DecodePNG(URLResponsePtr response) {
     int content_length = GetContentLength(response->headers);
     scoped_ptr<unsigned char[]> data(new unsigned char[content_length]);
     unsigned char* buf = data.get();
     uint32_t bytes_remaining = content_length;
     uint32_t num_bytes = bytes_remaining;
     while (bytes_remaining > 0) {
-      MojoResult result = ReadDataRaw(
-          response->body.get(), buf, &num_bytes, MOJO_READ_DATA_FLAG_NONE);
+      MojoResult result = ReadDataRaw(response->body.get(), buf, &num_bytes,
+                                      MOJO_READ_DATA_FLAG_NONE);
       if (result == MOJO_RESULT_SHOULD_WAIT) {
-        Wait(response->body.get(),
-             MOJO_HANDLE_SIGNAL_READABLE,
+        Wait(response->body.get(), MOJO_HANDLE_SIGNAL_READABLE,
              MOJO_DEADLINE_INDEFINITE);
       } else if (result == MOJO_RESULT_OK) {
         buf += num_bytes;
         num_bytes = bytes_remaining -= num_bytes;
       } else {
         break;
       }
     }
 
     bitmap_.reset(new std::vector<unsigned char>);
     gfx::PNGCodec::Decode(static_cast<const unsigned char*>(data.get()),
-                          content_length,
-                          gfx::PNGCodec::FORMAT_BGRA,
-                          bitmap_.get(),
-                          &width_,
-                          &height_);
+                          content_length, gfx::PNGCodec::FORMAT_BGRA,
+                          bitmap_.get(), &width_, &height_);
   }
 
   int GetContentLength(const Array<String>& headers) {
     for (size_t i = 0; i < headers.size(); ++i) {
       base::StringTokenizer t(headers[i], ": ;=");
       while (t.GetNext()) {
         if (!t.token_is_delim() && t.token() == "Content-Length") {
           while (t.GetNext()) {
             if (!t.token_is_delim())
               return atoi(t.token().c_str());
           }
         }
       }
     }
     return 0;
   }
 
   int width_;
   int height_;
   scoped_ptr<std::vector<unsigned char>> bitmap_;
   ApplicationImpl* app_;
-  View* root_;
+  std::map<View*, EmbedderData*> embedder_for_roots_;
   scoped_ptr<ViewManagerClientFactory> view_manager_client_factory_;
   uint16_t zoom_percentage_;
-  scoped_ptr<BitmapUploader> bitmap_uploader_;
 
   DISALLOW_COPY_AND_ASSIGN(PNGView);
 };
 
 class PNGViewer : public ApplicationDelegate,
                   public ContentHandlerFactory::Delegate {
  public:
   PNGViewer() : content_handler_factory_(this) {}
 
  private:
@@ skipping 16 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(PNGViewer);
 };
 
 }  // namespace examples
 }  // namespace mojo
 
 MojoResult MojoMain(MojoHandle shell_handle) {
   mojo::ApplicationRunnerChromium runner(new mojo::examples::PNGViewer());
   return runner.Run(shell_handle);
 }