Bug 1146214 - Rename some functions after refactoring. r=nical
authorEthan Lin <etlin@mozilla.com>
Fri, 10 Apr 2015 02:21:00 +0200
changeset 239706 893e3ebffee0b33699fd2884c8327f912c44b565
parent 239705 ef36caa16cf31bc12898ad20cd164bc6cb0265b4
child 239707 810cafba6ece138eaf3db651dc2f7b4009612228
push id12444
push userryanvm@gmail.com
push dateFri, 17 Apr 2015 20:04:42 +0000
treeherderfx-team@560a202db924 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersnical
bugs1146214
milestone40.0a1
Bug 1146214 - Rename some functions after refactoring. r=nical
gfx/layers/ipc/CompositableTransactionParent.cpp
gfx/layers/ipc/CompositableTransactionParent.h
gfx/layers/ipc/ImageBridgeParent.cpp
gfx/layers/ipc/ImageBridgeParent.h
gfx/layers/ipc/LayerTransactionParent.cpp
--- a/gfx/layers/ipc/CompositableTransactionParent.cpp
+++ b/gfx/layers/ipc/CompositableTransactionParent.cpp
@@ -140,17 +140,17 @@ CompositableParentManager::ReceiveCompos
       CompositableHost* compositable = AsCompositable(op);
       RefPtr<TextureHost> tex = TextureHost::AsTextureHost(op.textureParent());
 
       MOZ_ASSERT(tex.get());
       compositable->RemoveTextureHost(tex);
 
       if (!IsAsync() && ImageBridgeParent::GetInstance(GetChildProcessId())) {
         // send FenceHandle if present via ImageBridge.
-        ImageBridgeParent::SendFenceHandleToTrackerIfPresent(
+        ImageBridgeParent::AppendDeliverFenceMessage(
                              GetChildProcessId(),
                              op.holderId(),
                              op.transactionId(),
                              op.textureParent(),
                              compositable);
 
         // If the message is recievied via PLayerTransaction,
         // Send message back via PImageBridge.
@@ -223,17 +223,17 @@ CompositableParentManager::ReceiveCompos
       MOZ_ASSERT(false, "bad type");
     }
   }
 
   return true;
 }
 
 void
-CompositableParentManager::SendPendingAsyncMessges()
+CompositableParentManager::SendPendingAsyncMessages()
 {
   if (mPendingAsyncMessage.empty()) {
     return;
   }
 
   // Some type of AsyncParentMessageData message could have
   // one file descriptor (e.g. OpDeliverFence).
   // A number of file descriptors per gecko ipc message have a limitation
--- a/gfx/layers/ipc/CompositableTransactionParent.h
+++ b/gfx/layers/ipc/CompositableTransactionParent.h
@@ -29,17 +29,17 @@ typedef std::vector<mozilla::layers::Edi
 class CompositableParentManager : public ISurfaceAllocator
 {
 public:
   virtual void SendFenceHandleIfPresent(PTextureParent* aTexture,
                                         CompositableHost* aCompositableHost) = 0;
 
   virtual void SendAsyncMessage(const InfallibleTArray<AsyncParentMessageData>& aMessage) = 0;
 
-  void SendPendingAsyncMessges();
+  void SendPendingAsyncMessages();
 
   /**
    * Get child side's process Id.
    */
   virtual base::ProcessId GetChildProcessId() = 0;
 
 protected:
   /**
--- a/gfx/layers/ipc/ImageBridgeParent.cpp
+++ b/gfx/layers/ipc/ImageBridgeParent.cpp
@@ -98,17 +98,17 @@ ImageBridgeParent::ActorDestroy(ActorDes
 class MOZ_STACK_CLASS AutoImageBridgeParentAsyncMessageSender
 {
 public:
   explicit AutoImageBridgeParentAsyncMessageSender(ImageBridgeParent* aImageBridge)
     : mImageBridge(aImageBridge) {}
 
   ~AutoImageBridgeParentAsyncMessageSender()
   {
-    mImageBridge->SendPendingAsyncMessges();
+    mImageBridge->SendPendingAsyncMessages();
   }
 private:
   ImageBridgeParent* mImageBridge;
 };
 
 bool
 ImageBridgeParent::RecvUpdate(EditArray&& aEdits, EditReplyArray* aReply)
 {
@@ -334,20 +334,20 @@ ImageBridgeParent::SendFenceHandleIfPres
   FenceHandle fence = texture->GetAndResetReleaseFenceHandle();
   if (fence.IsValid()) {
     mPendingAsyncMessage.push_back(OpDeliverFence(aTexture, nullptr,
                                                   fence));
   }
 }
 
 void
-ImageBridgeParent::SendFenceHandleToTrackerIfPresent(uint64_t aDestHolderId,
-                                                     uint64_t aTransactionId,
-                                                     PTextureParent* aTexture,
-                                                     CompositableHost* aCompositableHost)
+ImageBridgeParent::AppendDeliverFenceMessage(uint64_t aDestHolderId,
+                                             uint64_t aTransactionId,
+                                             PTextureParent* aTexture,
+                                             CompositableHost* aCompositableHost)
 {
   RefPtr<TextureHost> texture = TextureHost::AsTextureHost(aTexture);
   if (!texture) {
     return;
   }
 
   // Send a ReleaseFence of CompositorOGL.
   if (aCompositableHost && aCompositableHost->GetCompositor()) {
@@ -364,36 +364,36 @@ ImageBridgeParent::SendFenceHandleToTrac
   if (fence.IsValid()) {
     mPendingAsyncMessage.push_back(OpDeliverFenceToTracker(aDestHolderId,
                                                            aTransactionId,
                                                            fence));
   }
 }
 
 /*static*/ void
-ImageBridgeParent::SendFenceHandleToTrackerIfPresent(base::ProcessId aChildProcessId,
-                                                     uint64_t aDestHolderId,
-                                                     uint64_t aTransactionId,
-                                                     PTextureParent* aTexture,
-                                                     CompositableHost* aCompositableHost)
+ImageBridgeParent::AppendDeliverFenceMessage(base::ProcessId aChildProcessId,
+                                             uint64_t aDestHolderId,
+                                             uint64_t aTransactionId,
+                                             PTextureParent* aTexture,
+                                             CompositableHost* aCompositableHost)
 {
   ImageBridgeParent* imageBridge = ImageBridgeParent::GetInstance(aChildProcessId);
   if (!imageBridge) {
     return;
   }
-  imageBridge->SendFenceHandleToTrackerIfPresent(aDestHolderId,
-                                                 aTransactionId,
-                                                 aTexture,
-                                                 aCompositableHost);
+  imageBridge->AppendDeliverFenceMessage(aDestHolderId,
+                                         aTransactionId,
+                                         aTexture,
+                                         aCompositableHost);
 }
 
 /*static*/ void
-ImageBridgeParent::SendPendingAsyncMessges(base::ProcessId aChildProcessId)
+ImageBridgeParent::SendPendingAsyncMessages(base::ProcessId aChildProcessId)
 {
   ImageBridgeParent* imageBridge = ImageBridgeParent::GetInstance(aChildProcessId);
   if (!imageBridge) {
     return;
   }
-  imageBridge->SendPendingAsyncMessges();
+  imageBridge->SendPendingAsyncMessages();
 }
 
 } // layers
 } // mozilla
--- a/gfx/layers/ipc/ImageBridgeParent.h
+++ b/gfx/layers/ipc/ImageBridgeParent.h
@@ -114,29 +114,29 @@ public:
 
   virtual bool IsSameProcess() const override;
 
   virtual void ReplyRemoveTexture(const OpReplyRemoveTexture& aReply) override;
 
   static void ReplyRemoveTexture(base::ProcessId aChildProcessId,
                                  const OpReplyRemoveTexture& aReply);
 
-  void SendFenceHandleToTrackerIfPresent(uint64_t aDestHolderId,
-                                         uint64_t aTransactionId,
-                                         PTextureParent* aTexture,
-                                         CompositableHost* aCompositableHost);
+  void AppendDeliverFenceMessage(uint64_t aDestHolderId,
+                                 uint64_t aTransactionId,
+                                 PTextureParent* aTexture,
+                                 CompositableHost* aCompositableHost);
 
-  static void SendFenceHandleToTrackerIfPresent(base::ProcessId aChildProcessId,
-                                                uint64_t aDestHolderId,
-                                                uint64_t aTransactionId,
-                                                PTextureParent* aTexture,
-                                                CompositableHost* aCompositableHost);
+  static void AppendDeliverFenceMessage(base::ProcessId aChildProcessId,
+                                        uint64_t aDestHolderId,
+                                        uint64_t aTransactionId,
+                                        PTextureParent* aTexture,
+                                        CompositableHost* aCompositableHost);
 
-  using CompositableParentManager::SendPendingAsyncMessges;
-  static void SendPendingAsyncMessges(base::ProcessId aChildProcessId);
+  using CompositableParentManager::SendPendingAsyncMessages;
+  static void SendPendingAsyncMessages(base::ProcessId aChildProcessId);
 
   static ImageBridgeParent* GetInstance(ProcessId aId);
 
   // Overriden from IToplevelProtocol
   IToplevelProtocol*
   CloneToplevel(const InfallibleTArray<ProtocolFdMapping>& aFds,
                 base::ProcessHandle aPeerProcess,
                 mozilla::ipc::ProtocolCloneContext* aCtx) override;
--- a/gfx/layers/ipc/LayerTransactionParent.cpp
+++ b/gfx/layers/ipc/LayerTransactionParent.cpp
@@ -206,18 +206,18 @@ LayerTransactionParent::RecvUpdateNoSwap
 class MOZ_STACK_CLASS AutoLayerTransactionParentAsyncMessageSender
 {
 public:
   explicit AutoLayerTransactionParentAsyncMessageSender(LayerTransactionParent* aLayerTransaction)
     : mLayerTransaction(aLayerTransaction) {}
 
   ~AutoLayerTransactionParentAsyncMessageSender()
   {
-    mLayerTransaction->SendPendingAsyncMessges();
-    ImageBridgeParent::SendPendingAsyncMessges(mLayerTransaction->GetChildProcessId());
+    mLayerTransaction->SendPendingAsyncMessages();
+    ImageBridgeParent::SendPendingAsyncMessages(mLayerTransaction->GetChildProcessId());
   }
 private:
   LayerTransactionParent* mLayerTransaction;
 };
 
 bool
 LayerTransactionParent::RecvUpdate(InfallibleTArray<Edit>&& cset,
                                    const uint64_t& aTransactionId,
@@ -920,17 +920,17 @@ LayerTransactionParent::RecvChildAsyncMe
         RefPtr<TextureHost> tex = TextureHost::AsTextureHost(op.textureParent());
 
         MOZ_ASSERT(tex.get());
         compositable->RemoveTextureHost(tex);
 
         MOZ_ASSERT(ImageBridgeParent::GetInstance(GetChildProcessId()));
         if (ImageBridgeParent::GetInstance(GetChildProcessId())) {
           // send FenceHandle if present via ImageBridge.
-          ImageBridgeParent::SendFenceHandleToTrackerIfPresent(
+          ImageBridgeParent::AppendDeliverFenceMessage(
             GetChildProcessId(),
             op.holderId(),
             op.transactionId(),
             op.textureParent(),
             compositable);
           // Send message back via PImageBridge.
           ImageBridgeParent::ReplyRemoveTexture(
             GetChildProcessId(),